--return Library

--[[if _G.Sigma then

return warn'Already loaded.'
end

_G.Sigma = true]]

local Library = loadstring(game:HttpGet("[Link]

local main = [Link]()

local rage = main:create_tab('Autoparry', 'rbxassetid://76499042599127')

local detectionstab = main:create_tab('Detection', 'rbxassetid://10734951847')
local set = main:create_tab('Spam', 'rbxassetid://10709781460')
local pl = main:create_tab('Player', 'rbxassetid://126017907477623')
local visuals = main:create_tab('Visuals', 'rbxassetid://10723346959')
local misc = main:create_tab('Misc', 'rbxassetid://132243429647479')
local devJV = main:create_tab('Exclusive', 'rbxassetid://10734966248')

repeat [Link]() until game:IsLoaded()

local Players = cloneref(game:GetService('Players'))

local ReplicatedStorage = cloneref(game:GetService('ReplicatedStorage'))
local UserInputService = cloneref(game:GetService('UserInputService'))
local RunService = cloneref(game:GetService('RunService'))
local TweenService = cloneref(game:GetService('TweenService'))
local Stats = cloneref(game:GetService('Stats'))
local Debris = cloneref(game:GetService('Debris'))
local CoreGui = cloneref(game:GetService('CoreGui'))

local LocalPlayer = [Link]

local Mouse = LocalPlayer:GetMouse()

if not [Link] then

[Link]:Wait()
end

local Alive = workspace:FindFirstChild("Alive") or workspace:WaitForChild("Alive")

local Runtime = [Link]

local System = {
__properties = {
__autoparry_enabled = false,
__triggerbot_enabled = false,
__manual_spam_enabled = false,
__auto_spam_enabled = false,
__play_animation = false,
__curve_mode = 1,
__accuracy = 1,
__divisor_multiplier = 1.1,
__parried = false,
__training_parried = false,
__spam_threshold = 1.5,
__parries = 0,
__parry_key = nil,
__grab_animation = nil,
__tornado_time = tick(),
 __first_parry_done = false,
__connections = {},
__reverted_remotes = {},
__spam_accumulator = 0,
__spam_rate = 240,
__infinity_active = false,
__deathslash_active = false,
__timehole_active = false,
__slashesoffury_active = false,
__slashesoffury_count = 0,
__is_mobile = [Link] and not
[Link],
__mobile_guis = {}
},

__config = {
__curve_names = {'Camera', 'Random', 'Accelerated', 'Backwards', 'Slow',
'High'},
__detections = {
__infinity = false,
__deathslash = false,
__timehole = false,
__slashesoffury = false,
__phantom = false
}
},

__triggerbot = {
__enabled = false,
__is_parrying = false,
__parries = 0,
__max_parries = 10000,
__parry_delay = 0.5
}
}

local revertedRemotes = {}
local originalMetatables = {}
local Parry_Key = nil
local PF = nil
local SC = nil

if ReplicatedStorage:FindFirstChild("Controllers") then
for _, child in ipairs([Link]:GetChildren()) do
if [Link]:match("^SwordsController%s*$") then
SC = child
end
end
end

if [Link]:FindFirstChild("Hotbar") and
[Link]:FindFirstChild("Block") then
for _, v in next, getconnections([Link])
do
if SC and getfenv([Link]).script == SC then
PF = [Link]
break
end
end
end

local function update_divisor()

System.__properties.__divisor_multiplier = 0.75 +
(System.__properties.__accuracy - 1) * (3 / 99)
end

function isValidRemoteArgs(args)
return #args == 7 and
type(args[2]) == "string" and
type(args[3]) == "number" and
typeof(args[4]) == "CFrame" and
type(args[5]) == "table" and
type(args[6]) == "table" and
type(args[7]) == "boolean"
end

function hookRemote(remote)
if not revertedRemotes[remote] then
if not originalMetatables[getrawmetatable(remote)] then
originalMetatables[getrawmetatable(remote)] = true
local meta = getrawmetatable(remote)
setreadonly(meta, false)

local oldIndex = meta.__index

meta.__index = function(self, key)
if (key == "FireServer" and self:IsA("RemoteEvent")) or
(key == "InvokeServer" and self:IsA("RemoteFunction")) then
return function(_, ...)
local args = {...}
if isValidRemoteArgs(args) and not revertedRemotes[self]
then
revertedRemotes[self] = args
Parry_Key = args[2]
end
return oldIndex(self, key)(_, unpack(args))
end
end
return oldIndex(self, key)
end
setreadonly(meta, true)
end
end
end

for _, remote in pairs(ReplicatedStorage:GetChildren()) do

if remote:IsA("RemoteEvent") or remote:IsA("RemoteFunction") then
hookRemote(remote)
end
end

[Link]:Connect(function(child)
if child:IsA("RemoteEvent") or child:IsA("RemoteFunction") then
hookRemote(child)
end
end)

[Link] = {}
function [Link].play_grab_parry()
if not System.__properties.__play_animation then
return
end

local character = [Link]

if not character then return end

local humanoid = character:FindFirstChildOfClass('Humanoid')

local animator = humanoid and humanoid:FindFirstChildOfClass('Animator')
if not humanoid or not animator then return end

local sword_name
if getgenv().skinChangerEnabled then
sword_name = getgenv().swordAnimations
else
sword_name = character:GetAttribute('CurrentlyEquippedSword')
end
if not sword_name then return end

local sword_api = [Link]

local parry_animation = sword_api.Default:FindFirstChild('GrabParry')
if not parry_animation then return end

local sword_data =
[Link]:Invoke(sword_name)
if not sword_data or not sword_data['AnimationType'] then return end

for _, object in pairs(sword_api:GetChildren()) do

if [Link] == sword_data['AnimationType'] then
if object:FindFirstChild('GrabParry') or object:FindFirstChild('Grab')
then
local animation_type = object:FindFirstChild('GrabParry') and
'GrabParry' or 'Grab'
parry_animation = object[animation_type]
end
end
end

if System.__properties.__grab_animation and
System.__properties.__grab_animation.IsPlaying then
System.__properties.__grab_animation:Stop()
end

System.__properties.__grab_animation = animator:LoadAnimation(parry_animation)
System.__properties.__grab_animation.Priority = [Link].Action4
System.__properties.__grab_animation:Play()
end

[Link] = {}

function [Link]()
local balls = workspace:FindFirstChild('Balls')
if not balls then return nil end

for _, ball in pairs(balls:GetChildren()) do

if ball:GetAttribute('realBall') then
[Link] = false
return ball
 end
end
return nil
end

function [Link].get_all()
local balls_table = {}
local balls = workspace:FindFirstChild('Balls')
if not balls then return balls_table end

for _, ball in pairs(balls:GetChildren()) do

if ball:GetAttribute('realBall') then
[Link] = false
[Link](balls_table, ball)
end
end
return balls_table
end

[Link] = {}

local Closest_Entity = nil

function [Link].get_closest()
local max_distance = [Link]
local closest_entity = nil

if not Alive then return nil end

for _, entity in pairs(Alive:GetChildren()) do

if entity ~= [Link] then
if [Link] then
local distance =
LocalPlayer:DistanceFromCharacter([Link])
if distance < max_distance then
max_distance = distance
closest_entity = entity
end
end
end
end

Closest_Entity = closest_entity
return closest_entity
end

function [Link].get_closest_to_cursor()
if not [Link] or not
[Link]:FindFirstChild('HumanoidRootPart') then
return nil
end

local closest_player = nil

local minimal_dot = -[Link]
local camera = [Link]

if not Alive then return nil end

local success, mouse_location = pcall(function()

 return UserInputService:GetMouseLocation()
end)

if not success then return nil end

local ray = camera:ScreenPointToRay(mouse_location.X, mouse_location.Y)

local pointer = [Link]([Link], [Link] + [Link])

for _, player in pairs(Alive:GetChildren()) do

if player == [Link] then continue end
if not player:FindFirstChild('HumanoidRootPart') then continue end

local direction = ([Link] -

[Link]).Unit
local dot = [Link]:Dot(direction)

if dot > minimal_dot then

minimal_dot = dot
closest_player = player
end
end

return closest_player
end

[Link] = {}

function [Link].get_cframe()
local camera = [Link]
local root = [Link] and
[Link]:FindFirstChild('HumanoidRootPart')
if not root then return [Link] end

local targetPart
local closest = [Link].get_closest_to_cursor()
if closest and closest:FindFirstChild('HumanoidRootPart') then
targetPart = [Link]
end

local target_pos = targetPart and [Link] or ([Link] +

[Link] * 100)

local curve_functions = {
function() return [Link] end,

function()
local direction = (target_pos - [Link]).Unit
local random_offset
local attempts = 0
repeat
random_offset = [Link](
[Link](-4000, 4000),
[Link](-4000, 4000),
[Link](-4000, 4000)
)
local curve_direction = (target_pos + random_offset -
[Link]).Unit
local dot = direction:Dot(curve_direction)
attempts = attempts + 1
 until dot < 0.95 or attempts > 10
return [Link]([Link], target_pos + random_offset)
end,

function()
return [Link]([Link], target_pos + [Link](0, 5, 0))
end,

function()
local direction = ([Link] - target_pos).Unit
local backwards_pos = [Link] + direction * 10000 +
[Link](0, 1000, 0)
return [Link]([Link], backwards_pos)
end,

function()
return [Link]([Link], target_pos + [Link](0, -9e18, 0))
end,

function()
return [Link]([Link], target_pos + [Link](0, 9e18, 0))
end
}

return curve_functions[System.__properties.__curve_mode]()
end

[Link] = {}

function [Link]()
if System.__properties.__parries > 10000 or not [Link] then
return
end

local camera = [Link]

local success, mouse = pcall(function()
return UserInputService:GetMouseLocation()
end)

if not success then return end

local vec2_mouse = {mouse.X, mouse.Y}

local is_mobile = System.__properties.__is_mobile

local event_data = {}
if Alive then
for _, entity in pairs(Alive:GetChildren()) do
if [Link] then
local success2, screen_point = pcall(function()
return camera:WorldToScreenPoint([Link])
end)
if success2 then
event_data[[Link]] = screen_point
end
end
end
end

local curve_cframe = [Link].get_cframe()

 if not System.__properties.__first_parry_done then
for _, connection in
pairs(getconnections([Link])) do
connection:Fire()
end
System.__properties.__first_parry_done = true
return
end

local final_aim_target
if is_mobile then
local viewport = [Link]
final_aim_target = {viewport.X / 2, viewport.Y / 2}
else
final_aim_target = vec2_mouse
end

for remote, original_args in pairs(revertedRemotes) do

local modified_args = {
original_args[1],
original_args[2],
original_args[3],
curve_cframe,
event_data,
final_aim_target,
original_args[7]
}

pcall(function()
if remote:IsA('RemoteEvent') then
remote:FireServer(unpack(modified_args))
elseif remote:IsA('RemoteFunction') then
remote:InvokeServer(unpack(modified_args))
end
end)
end

if System.__properties.__parries > 10000 then return end

System.__properties.__parries = System.__properties.__parries + 1
[Link](0.5, function()
if System.__properties.__parries > 0 then
System.__properties.__parries = System.__properties.__parries - 1
end
end)
end

function [Link]()
if System.__properties.__parries > 10000 or not [Link] then
return
end

PF()

if System.__properties.__parries > 10000 then return end

System.__properties.__parries = System.__properties.__parries + 1
[Link](0.5, function()
 if System.__properties.__parries > 0 then
System.__properties.__parries = System.__properties.__parries - 1
end
end)
end

-- // aqqqqq

function [Link].execute_action()
[Link].play_grab_parry()
[Link]()
end

local function linear_predict(a, b, time_volume)

return a + (b - a) * time_volume
end

[Link] = {
__ball_properties = {
__aerodynamic_time = tick(),
__last_warping = tick(),
__lerp_radians = 0,
__curving = tick()
}
}

function [Link].is_curved()
local ball_properties = [Link].__ball_properties
local ball = [Link]()

if not ball then return false end

local zoomies = ball:FindFirstChild('zoomies')

if not zoomies then return false end

local velocity = [Link]

local ball_direction = [Link]

local direction = ([Link] -

[Link]).Unit
local dot = direction:Dot(ball_direction)

local speed = [Link]

local speed_threshold = [Link](speed / 100, 40)

local direction_difference = (ball_direction - velocity).Unit

local direction_similarity = direction:Dot(direction_difference)

local dot_difference = dot - direction_similarity

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

local ping = [Link]['Data Ping']:GetValue()

local dot_threshold = 0.5 - (ping / 1000)

local reach_time = distance / speed - (ping / 1000)

local ball_distance_threshold = 15 - [Link](distance / 1000, 15) +

speed_threshold
 local clamped_dot = [Link](dot, -1, 1)
local radians = [Link]([Link](clamped_dot))

ball_properties.__lerp_radians = linear_predict(ball_properties.__lerp_radians,
radians, 0.8)

if speed > 0 and reach_time > ping / 10 then

ball_distance_threshold = [Link](ball_distance_threshold - 15, 15)
end

if distance < ball_distance_threshold then return false end

if dot_difference < dot_threshold then return true end

if ball_properties.__lerp_radians < 0.018 then

ball_properties.__last_warping = tick()
end

if (tick() - ball_properties.__last_warping) < (reach_time / 1.5) then

return true
end

if (tick() - ball_properties.__curving) < (reach_time / 1.5) then

return true
end

return dot < dot_threshold

end

[Link]:Connect(function(c, d)
System.__properties.__deathslash_active = d or false
end)

[Link]:Connect(function(a, b)
System.__properties.__infinity_active = b or false
end)

[Link]._Index["sleitnick_net@0.1.0"].net["RE/
TimeHoleActivate"].OnClientEvent:Connect(function(...)
local args = {...}
local player = args[1]

if player == LocalPlayer or player == [Link] or (player and

[Link] == [Link]) then
System.__properties.__timehole_active = true
end
end)

[Link]._Index["sleitnick_net@0.1.0"].net["RE/
TimeHoleDeactivate"].OnClientEvent:Connect(function()
System.__properties.__timehole_active = false
end)

local maxParryCount = 36
local parryDelay = 0.05

[Link]._Index["sleitnick_net@0.1.0"].net["RE/
SlashesOfFuryActivate"].OnClientEvent:Connect(function(...)
local args = {...}
 local player = args[1]

if player == LocalPlayer or player == [Link] or (player and

[Link] == [Link]) then
System.__properties.__slashesoffury_active = true
System.__properties.__slashesoffury_count = 0
end
end)

[Link]._Index["sleitnick_net@0.1.0"].net["RE/
SlashesOfFuryEnd"].OnClientEvent:Connect(function()
System.__properties.__slashesoffury_active = false
System.__properties.__slashesoffury_count = 0
end)

[Link]._Index["sleitnick_net@0.1.0"].net["RE/
SlashesOfFuryParry"].OnClientEvent:Connect(function()
System.__properties.__slashesoffury_count =
System.__properties.__slashesoffury_count + 1
end)

[Link]._Index["sleitnick_net@0.1.0"].net["RE/
SlashesOfFuryCatch"].OnClientEvent:Connect(function()
spawn(function()
while System.__properties.__slashesoffury_active and
System.__properties.__slashesoffury_count < maxParryCount do
if System.__config.__detections.__slashesoffury then
[Link]()
[Link](parryDelay)
else
break
end
end
end)
end)

[Link]:Connect(function(Object)
if System.__config.__detections.__phantom then
if [Link] == "maxTransmission" or [Link] == "transmissionpart"
then
local Weld = Object:FindFirstChildWhichIsA("WeldConstraint")
if Weld then
local Character = [Link] or
[Link]:Wait()
if Character and Weld.Part1 == [Link] then
local CurrentBall = [Link]()
Weld:Destroy()

if CurrentBall then
local FocusConnection
FocusConnection =
[Link]:Connect(function()
local Highlighted =
CurrentBall:GetAttribute("highlighted")

if Highlighted == true then

[Link]:Fire()
System.__properties.__parried = true
 [Link](1, function()
System.__properties.__parried = false
end)

elseif Highlighted == false then

FocusConnection:Disconnect()
end
end)

[Link](3, function()
if FocusConnection and [Link] then
FocusConnection:Disconnect()
end
end)
end
end
end
end
end
end)

[Link]:Connect(function(_, root)
if [Link] and [Link] ~= [Link] then
if not Alive or [Link] ~= Alive then
return
end
end

local closest = [Link].get_closest()

local ball = [Link]()

if not ball or not closest then return end

local target_distance = ([Link] -

[Link]).Magnitude
local distance = ([Link] -
[Link]).Magnitude
local direction = ([Link] -
[Link]).Unit
local dot = direction:Dot([Link])

local curve_detected = [Link].is_curved()

if target_distance < 15 and distance < 15 and dot > -0.25 then
if curve_detected then
[Link].execute_action()
end
end

if System.__properties.__grab_animation then
System.__properties.__grab_animation:Stop()
end
end)

[Link]:Connect(function()
if not Alive or [Link] ~= Alive then
return
end
 if System.__properties.__grab_animation then
System.__properties.__grab_animation:Stop()
end
end)

[Link]:Connect(function(a, b)
local Primary_Part = [Link]
local Ball = [Link]()

if not Ball then

return
end

local Zoomies = Ball:FindFirstChild('zoomies')

if not Zoomies then

return
end

local Speed = [Link]

local Distance = ([Link] -

[Link]).Magnitude
local Velocity = [Link]

local Ball_Direction = [Link]

local Direction = ([Link] -

[Link]).Unit
local Dot = Direction:Dot(Ball_Direction)

local Pings = [Link]['Data Ping']:GetValue()

local Speed_Threshold = [Link](Speed / 100, 40)

local Reach_Time = Distance / Speed - (Pings / 1000)

local Enough_Speed = Speed > 1

local Ball_Distance_Threshold = 15 - [Link](Distance / 1000, 15) +
Speed_Threshold

if Enough_Speed and Reach_Time > Pings / 10 then

Ball_Distance_Threshold = [Link](Ball_Distance_Threshold - 15, 15)
end

if b ~= Primary_Part and Distance > Ball_Distance_Threshold then

[Link].__ball_properties.__curving = tick()
end
end)

[Link] = {}

function [Link](ball)
if System.__triggerbot.__is_parrying or System.__triggerbot.__parries >
System.__triggerbot.__max_parries then
return
end

if [Link] and [Link] and

[Link]:FindFirstChild('SingularityCape') then
 return
end

System.__triggerbot.__is_parrying = true
System.__triggerbot.__parries = System.__triggerbot.__parries + 1

[Link].play_grab_parry()
[Link]()

[Link](System.__triggerbot.__parry_delay, function()
if System.__triggerbot.__parries > 0 then
System.__triggerbot.__parries = System.__triggerbot.__parries - 1
end
end)

local connection
connection = ball:GetAttributeChangedSignal('target'):Once(function()
System.__triggerbot.__is_parrying = false
if connection then
connection:Disconnect()
end
end)

[Link](function()
local start_time = tick()
repeat
[Link]:Wait()
until (tick() - start_time >= 1 or not System.__triggerbot.__is_parrying)

System.__triggerbot.__is_parrying = false
end)
end

function [Link]()
if not System.__triggerbot.__enabled then return end

if [Link] and [Link] and

[Link]:FindFirstChild('SingularityCape') then
return
end

local balls = workspace:FindFirstChild('Balls')

if not balls then return end

for _, ball in pairs(balls:GetChildren()) do

if ball:IsA('BasePart') and ball:GetAttribute('target') == [Link]
then
[Link](ball)
break
end
end
end

function [Link](enabled)
System.__triggerbot.__enabled = enabled

if enabled then
if not System.__properties.__connections.__triggerbot then
System.__properties.__connections.__triggerbot =
[Link]:Connect([Link])
end
else
if System.__properties.__connections.__triggerbot then
System.__properties.__connections.__triggerbot:Disconnect()
System.__properties.__connections.__triggerbot = nil
end
System.__triggerbot.__is_parrying = false
System.__triggerbot.__parries = 0
end
end

System.manual_spam = {}

function System.manual_spam.loop(delta)
if not System.__properties.__manual_spam_enabled then return end
if not [Link] or [Link] ~= Alive then
return end

System.__properties.__spam_accumulator = System.__properties.__spam_accumulator
+ delta
local interval = 1 / System.__properties.__spam_rate

if System.__properties.__spam_accumulator >= interval then

System.__properties.__spam_accumulator = 0

if getgenv().ManualSpamMode == "Keypress" then

if PF then PF() end
else
[Link]()
if getgenv().ManualSpamAnimationFix and PF then
PF()
end
end
end
end

function System.manual_spam.start()
if System.__properties.__connections.__manual_spam then
System.__properties.__connections.__manual_spam:Disconnect()
end

System.__properties.__manual_spam_enabled = true
System.__properties.__connections.__manual_spam =
[Link]:Connect(System.manual_spam.loop)
end

function System.manual_spam.stop()
System.__properties.__manual_spam_enabled = false
if System.__properties.__connections.__manual_spam then
System.__properties.__connections.__manual_spam:Disconnect()
System.__properties.__connections.__manual_spam = nil
end
end

System.auto_spam = {}

function System.auto_spam:get_entity_properties()
[Link].get_closest()
 if not Closest_Entity then return false end

local entity_velocity = Closest_Entity.[Link]

local entity_direction = ([Link] -
Closest_Entity.[Link]).Unit
local entity_distance = ([Link] -
Closest_Entity.[Link]).Magnitude

return {
Velocity = entity_velocity,
Direction = entity_direction,
Distance = entity_distance
}
end

function System.auto_spam:get_ball_properties()
local ball = [Link]()
if not ball then return false end

local ball_velocity = [Link]

local ball_origin = ball

local ball_direction = ([Link] -

ball_origin.Position).Unit
local ball_distance = ([Link] -
[Link]).Magnitude
local ball_dot = ball_direction:Dot(ball_velocity.Unit)

return {
Velocity = ball_velocity,
Direction = ball_direction,
Distance = ball_distance,
Dot = ball_dot
}
end

function System.auto_spam.spam_service(self)
local ball = [Link]()
local entity = [Link].get_closest()

if not ball or not entity or not [Link] then

return false
end

local spam_accuracy = 0

local velocity = [Link]

local speed = [Link]

local direction = ([Link] -

[Link]).Unit
local dot = direction:Dot([Link])

local target_position = [Link]

local target_distance = LocalPlayer:DistanceFromCharacter(target_position)

local maximum_spam_distance = [Link] + [Link](speed / 6, 255)

 if self.Entity_Properties.Distance > maximum_spam_distance then
return spam_accuracy
end

if self.Ball_Properties.Distance > maximum_spam_distance then

return spam_accuracy
end

if target_distance > maximum_spam_distance then

return spam_accuracy
end

local maximum_speed = 5 - [Link](speed / 5, 5)

local maximum_dot = [Link](dot, -1, 0) * maximum_speed

spam_accuracy = maximum_spam_distance - maximum_dot

return spam_accuracy
end

function System.auto_spam.start()
if System.__properties.__connections.__auto_spam then
System.__properties.__connections.__auto_spam:Disconnect()
end

System.__properties.__auto_spam_enabled = true
System.__properties.__connections.__auto_spam =
[Link]:Connect(function()
local ball = [Link]()

if not ball then return end

if System.__properties.__slashesoffury_active then return end

local zoomies = ball:FindFirstChild('zoomies')

if not zoomies then return end

[Link].get_closest()

local ping = [Link]['Data Ping']:GetValue()

local ping_threshold = [Link](ping / 10, 1, 16)

local ball_target = ball:GetAttribute('target')

local ball_properties = System.auto_spam:get_ball_properties()

local entity_properties = System.auto_spam:get_entity_properties()

if not ball_properties or not entity_properties then return end

local spam_accuracy = System.auto_spam.spam_service({

Ball_Properties = ball_properties,
Entity_Properties = entity_properties,
Ping = ping_threshold
})

local target_position = Closest_Entity.[Link]

local target_distance = LocalPlayer:DistanceFromCharacter(target_position)

local direction = ([Link] -

[Link]).Unit
local ball_direction = [Link]

local dot = direction:Dot(ball_direction)

local distance = LocalPlayer:DistanceFromCharacter([Link])

if not ball_target then return end

if target_distance > spam_accuracy or distance > spam_accuracy then return
end

local pulsed = [Link]:GetAttribute('Pulsed')

if pulsed then return end

if ball_target == [Link] and target_distance > 30 and distance >

30 then return end

if distance <= spam_accuracy and System.__properties.__parries

> System.__properties.__spam_threshold then
if getgenv().AutoSpamMode == "Keypress" then
if PF then PF() end
else
[Link]()
if getgenv().AutoSpamAnimationFix and PF then
PF()
end
end
end
end)
end

function System.auto_spam.stop()
System.__properties.__auto_spam_enabled = false
if System.__properties.__connections.__auto_spam then
System.__properties.__connections.__auto_spam:Disconnect()
System.__properties.__connections.__auto_spam = nil
end
end

[Link] = {}

function [Link]()
if System.__properties.__connections.__autoparry then
System.__properties.__connections.__autoparry:Disconnect()
end

System.__properties.__connections.__autoparry =
[Link]:Connect(function()
if not System.__properties.__autoparry_enabled or not [Link]
or
not [Link] then
return
end

local balls = [Link].get_all()

local one_ball = [Link]()

local training_ball = nil

if workspace:FindFirstChild("TrainingBalls") then
for _, Instance in pairs([Link]:GetChildren()) do
 if Instance:GetAttribute("realBall") then
training_ball = Instance
break
end
end
end

for _, ball in pairs(balls) do

if System.__triggerbot.__enabled then return end
if getgenv().BallVelocityAbove800 then return end
if not ball then continue end

local zoomies = ball:FindFirstChild('zoomies')

if not zoomies then continue end

ball:GetAttributeChangedSignal('target'):Once(function()
System.__properties.__parried = false
end)

if System.__properties.__parried then continue end

local ball_target = ball:GetAttribute('target')

local velocity = [Link]
local distance = ([Link] -
[Link]).Magnitude

local ping = [Link]['Data Ping']:GetValue() / 10

local ping_threshold = [Link](ping / 10, 5, 17)
local speed = [Link]

local capped_speed_diff = [Link]([Link](speed - 9.5, 0), 650)

local speed_divisor = (2.4 + capped_speed_diff * 0.002) *
System.__properties.__divisor_multiplier
local parry_accuracy = ping_threshold + [Link](speed / speed_divisor,
9.5)

local curved = [Link].is_curved()

if ball:FindFirstChild('AeroDynamicSlashVFX') then
[Link]:Destroy()
System.__properties.__tornado_time = tick()
end

if Runtime:FindFirstChild('Tornado') then
if (tick() - System.__properties.__tornado_time) <
([Link]:GetAttribute('TornadoTime') or 1) + 0.314159
then
continue
end
end

if one_ball and one_ball:GetAttribute('target') == [Link] and

curved then
continue
end

if ball:FindFirstChild('ComboCounter') then continue end

if [Link]:FindFirstChild('SingularityCape')
then continue end

if System.__config.__detections.__infinity and
System.__properties.__infinity_active then continue end
if System.__config.__detections.__deathslash and
System.__properties.__deathslash_active then continue end
if System.__config.__detections.__timehole and
System.__properties.__timehole_active then continue end
if System.__config.__detections.__slashesoffury and
System.__properties.__slashesoffury_active then continue end

if ball_target == [Link] and distance <= parry_accuracy then

if getgenv().CooldownProtection then
local ParryCD = [Link]
if [Link].Y < 0.4 then
[Link]:Fire()
continue
end
end

if getgenv().AutoAbility then
local AbilityCD =
[Link]
if [Link].Y == 0.5 then
if [Link]:FindFirstChild("Raging
Deflection") and [Link]["Raging Deflection"].Enabled or

[Link]:FindFirstChild("Rapture") and
[Link]["Rapture"].Enabled or
[Link]:FindFirstChild("Calming
Deflection") and [Link]["Calming Deflection"].Enabled or

[Link]:FindFirstChild("Aerodynamic Slash") and

[Link]["Aerodynamic Slash"].Enabled or

[Link]:FindFirstChild("Fracture") and
[Link]["Fracture"].Enabled or
[Link]:FindFirstChild("Death
Slash") and [Link]["Death Slash"].Enabled then
System.__properties.__parried = true
[Link]:Fire()
[Link](2.432)

ReplicatedStorage:WaitForChild("Remotes"):WaitForChild("DeathSlashShootActivation")
:FireServer(true)
continue
end
end
end
end

if ball_target == [Link] and distance <= parry_accuracy then

if getgenv().AutoParryMode == "Keypress" then
[Link]()
else
[Link].execute_action()
end
System.__properties.__parried = true
end
 local last_parrys = tick()
repeat
[Link]:Wait()
until (tick() - last_parrys) >= 1 or not System.__properties.__parried
System.__properties.__parried = false
end

if training_ball then
local zoomies = training_ball:FindFirstChild('zoomies')
if zoomies then
training_ball:GetAttributeChangedSignal('target'):Once(function()
System.__properties.__training_parried = false
end)

if not System.__properties.__training_parried then

local ball_target = training_ball:GetAttribute('target')
local velocity = [Link]
local distance =
LocalPlayer:DistanceFromCharacter(training_ball.Position)
local speed = [Link]

local ping = [Link]['Data

Ping']:GetValue() / 10
local ping_threshold = [Link](ping / 10, 5, 17)

local capped_speed_diff = [Link]([Link](speed - 9.5, 0),

650)
local speed_divisor = (2.4 + capped_speed_diff * 0.002) *
System.__properties.__divisor_multiplier
local parry_accuracy = ping_threshold + [Link](speed /
speed_divisor, 9.5)

if ball_target == [Link] and distance <=

parry_accuracy then
if getgenv().AutoParryMode == "Keypress" then
[Link]()
else
[Link].execute_action()
end
System.__properties.__training_parried = true

local last_parrys = tick()

repeat
[Link]:Wait()
until (tick() - last_parrys) >= 1 or not
System.__properties.__training_parried
System.__properties.__training_parried = false
end
end
end
end
end)
end

function [Link]()
if System.__properties.__connections.__autoparry then
System.__properties.__connections.__autoparry:Disconnect()
System.__properties.__connections.__autoparry = nil
 end
end

local function create_mobile_button(name, position_y, color)

local gui = [Link]('ScreenGui')
[Link] = 'Sigma' .. name .. 'Mobile'
[Link] = false
[Link] = true
[Link] = [Link]

local button = [Link]('TextButton')

[Link] = [Link](0, 140, 0, 50)
[Link] = [Link](0.5, -70, position_y, 0)
[Link] = 1
[Link] = [Link](0.5, 0)
[Link] = true
[Link] = false
[Link] = 2

local bg = [Link]('Frame')
[Link] = [Link](1, 0, 1, 0)
bg.BackgroundColor3 = [Link](40, 40, 40)
[Link] = button

local corner = [Link]('UICorner')

[Link] = [Link](0, 10)
[Link] = bg

local stroke = [Link]('UIStroke')

[Link] = color
[Link] = 1
[Link] = 0.3
[Link] = bg

local text = [Link]('TextLabel')

[Link] = [Link](1, 0, 1, 0)
[Link] = 1
[Link] = name
[Link] = [Link]
[Link] = 16
text.TextColor3 = [Link](255, 255, 255)
[Link] = 3
[Link] = button

[Link] = gui
[Link] = CoreGui

return {gui = gui, button = button, text = text, bg = bg}

end

local function create_mobile_button(name, position_y, color)

local gui = [Link]('ScreenGui')
[Link] = 'Sigma' .. name .. 'Mobile'
[Link] = false
[Link] = true
[Link] = [Link]

local button = [Link]('TextButton')

[Link] = [Link](0, 140, 0, 50)
 [Link] = [Link](0.5, -70, position_y, 0)
[Link] = 1
[Link] = [Link](0.5, 0)
[Link] = true
[Link] = false
[Link] = 2

local bg = [Link]('Frame')
[Link] = [Link](1, 0, 1, 0)
bg.BackgroundColor3 = [Link](40, 40, 40)
[Link] = button

local corner = [Link]('UICorner')

[Link] = [Link](0, 10)
[Link] = bg

local stroke = [Link]('UIStroke')

[Link] = color
[Link] = 1
[Link] = 0.3
[Link] = bg

local text = [Link]('TextLabel')

[Link] = [Link](1, 0, 1, 0)
[Link] = 1
[Link] = name
[Link] = [Link]
[Link] = 16
text.TextColor3 = [Link](255, 255, 255)
[Link] = 3
[Link] = button

[Link] = gui
[Link] = CoreGui

return {gui = gui, button = button, text = text, bg = bg}

end

local function destroy_mobile_gui(gui_data)

if gui_data and gui_data.gui then
gui_data.gui:Destroy()
end
end

local autoparry_module = rage:create_module({

title = 'Auto Parry',
flag = 'Auto_Parry',
description = 'Automatically parries ball',
section = 'left',
callback = function(value)
System.__properties.__autoparry_enabled = value
if value then
[Link]()
if getgenv().AutoParryNotify then
[Link]({
title = "Auto Parry",
text = "ON",
duration = 2
})
 end
else
[Link]()
if getgenv().AutoParryNotify then
[Link]({
title = "Auto Parry",
text = "OFF",
duration = 2
})
end
end
end
})

autoparry_module:create_dropdown({
title = "Parry Mode",
flag = "autoparry_mode",
options = {"Remote", "Keypress"},
default = "Remote",
multi_dropdown = false,
maximum_options = 2,
callback = function(value)
getgenv().AutoParryMode = value
end
})

local AutoCurveDropdown = autoparry_module:create_dropdown({

title = "AutoCurve",
flag = "curve_type",
options = System.__config.__curve_names,
multi_dropdown = false,
maximum_options = 6,
callback = function(value)
for i, name in ipairs(System.__config.__curve_names) do
if name == value then
System.__properties.__curve_mode = i
break
end
end
end
})

autoparry_module:create_slider({
title = 'Parry Accuracy',
flag = 'Parry_Accuracy',
maximum_value = 100,
minimum_value = 1,
value = 50,
round_number = true,
callback = function(value)
System.__properties.__accuracy = value
update_divisor()
end
})

autoparry_module:create_checkbox({
title = "Play Animation",
flag = "Play_Animation",
callback = function(value)
 System.__properties.__play_animation = value
end
})

autoparry_module:create_divider({})

autoparry_module:create_checkbox({
title = "Notify",
flag = "Auto_Parry_Notify",
callback = function(value)
getgenv().AutoParryNotify = value
end
})

autoparry_module:create_checkbox({
title = "Cooldown Protection",
flag = "CooldownProtection",
callback = function(value)
getgenv().CooldownProtection = value
end
})

autoparry_module:create_checkbox({
title = "Auto Ability",
flag = "AutoAbility",
callback = function(value)
getgenv().AutoAbility = value
end
})

local triggerbot_module = rage:create_module({

title = "Triggerbot",
description = "Parries instantly if targeted",
flag = "triggerbot",
section = 'right',
callback = function(value)
if System.__properties.__is_mobile then
if value then
if not System.__properties.__mobile_guis.triggerbot then
local triggerbot_mobile = create_mobile_button('Trigger', 0.7,
[Link](255, 100, 0))
System.__properties.__mobile_guis.triggerbot =
triggerbot_mobile

local touch_start = 0
local was_dragged = false

triggerbot_mobile.[Link]:Connect(function(input)
if [Link] == [Link] then
touch_start = tick()
was_dragged = false
end
end)

triggerbot_mobile.[Link]:Connect(function(input)
if [Link] == [Link] then
if (tick() - touch_start) > 0.1 then
was_dragged = true
end
 end
end)

triggerbot_mobile.[Link]:Connect(function(input)
if [Link] == [Link] and not
was_dragged then
System.__properties.__triggerbot_enabled = not
System.__properties.__triggerbot_enabled

[Link](System.__properties.__triggerbot_enabled)

if System.__properties.__triggerbot_enabled then
triggerbot_mobile.[Link] = "ON"
triggerbot_mobile.text.TextColor3 =
[Link](255, 100, 0)
else
triggerbot_mobile.[Link] = "Trigger"
triggerbot_mobile.text.TextColor3 =
[Link](255, 255, 255)
end

if getgenv().TriggerbotNotify then
[Link]({
title = "Triggerbot",
text = System.__properties.__triggerbot_enabled
and "ON" or "OFF",
duration = 2
})
end
end
end)
end
else
System.__properties.__triggerbot_enabled = false
[Link](false)
destroy_mobile_gui(System.__properties.__mobile_guis.triggerbot)
System.__properties.__mobile_guis.triggerbot = nil
end
else
System.__properties.__triggerbot_enabled = value
[Link](value)

if getgenv().TriggerbotNotify then
[Link]({
title = "Triggerbot",
text = value and "ON" or "OFF",
duration = 2
})
end
end
end
})

triggerbot_module:create_checkbox({
title = "Notify",
flag = "TriggerbotNotify",
callback = function(value)
getgenv().TriggerbotNotify = value
end
})

local function create_curve_selector_mobile()

local gui = [Link]('ScreenGui')
[Link] = 'SigmaCurveSelectorMobile'
[Link] = false
[Link] = true
[Link] = [Link]

local main_frame = [Link]('Frame')

main_frame.Size = [Link](0, 140, 0, 40)
main_frame.Position = [Link](0.5, -70, 0.12, 0)
main_frame.BackgroundColor3 = [Link](15, 15, 15)
main_frame.BorderSizePixel = 0
main_frame.AnchorPoint = [Link](0.5, 0)
main_frame.ZIndex = 5
main_frame.Parent = gui

local main_corner = [Link]('UICorner')

main_corner.CornerRadius = [Link](0, 8)
main_corner.Parent = main_frame

local main_stroke = [Link]('UIStroke')

main_stroke.Color = [Link](60, 60, 60)
main_stroke.Thickness = 1
main_stroke.Parent = main_frame

local header = [Link]('Frame')

[Link] = [Link](1, 0, 0, 40)
[Link] = 1
[Link] = 6
[Link] = main_frame

local header_text = [Link]('TextLabel')

header_text.Size = [Link](1, -35, 1, 0)
header_text.Position = [Link](0, 12, 0, 0)
header_text.BackgroundTransparency = 1
header_text.Text = "CURVE"
header_text.Font = [Link]
header_text.TextSize = 11
header_text.TextColor3 = [Link](180, 180, 180)
header_text.TextXAlignment = [Link]
header_text.ZIndex = 7
header_text.Parent = header

local toggle_btn = [Link]('TextButton')

toggle_btn.Size = [Link](0, 24, 0, 24)
toggle_btn.Position = [Link](1, -32, 0.5, -12)
toggle_btn.BackgroundColor3 = [Link](25, 25, 25)
toggle_btn.Text = "−"
toggle_btn.Font = [Link]
toggle_btn.TextSize = 14
toggle_btn.TextColor3 = [Link](200, 200, 200)
toggle_btn.AutoButtonColor = false
toggle_btn.ZIndex = 7
toggle_btn.Parent = header

local toggle_corner = [Link]('UICorner')

toggle_corner.CornerRadius = [Link](0, 4)
toggle_corner.Parent = toggle_btn

local toggle_stroke = [Link]('UIStroke')

toggle_stroke.Color = [Link](50, 50, 50)
toggle_stroke.Thickness = 1
toggle_stroke.Parent = toggle_btn

local buttons_container = [Link]('Frame')

buttons_container.Size = [Link](1, -16, 0, 0)
buttons_container.Position = [Link](0, 8, 0, 48)
buttons_container.BackgroundTransparency = 1
buttons_container.ClipsDescendants = true
buttons_container.ZIndex = 6
buttons_container.Parent = main_frame

local list_layout = [Link]('UIListLayout')

list_layout.Padding = [Link](0, 4)
list_layout.FillDirection = [Link]
list_layout.SortOrder = [Link]
list_layout.Parent = buttons_container

local CURVE_TYPES = {
{name = "Camera"},
{name = "Random"},
{name = "Accelerated"},
{name = "Backwards"},
{name = "Slow"},
{name = "High"}
}

local buttons = {}
local current_selected = nil

for i, curve_data in ipairs(CURVE_TYPES) do

local btn_container = [Link]('Frame')
btn_container.Size = [Link](1, 0, 0, 32)
btn_container.BackgroundTransparency = 1
btn_container.ZIndex = 7
btn_container.LayoutOrder = i
btn_container.Parent = buttons_container

local btn = [Link]('TextButton')

[Link] = [Link](1, 0, 1, 0)
btn.BackgroundColor3 = [Link](20, 20, 20)
[Link] = ""
[Link] = false
[Link] = 8
[Link] = btn_container

local btn_corner = [Link]('UICorner')

btn_corner.CornerRadius = [Link](0, 6)
btn_corner.Parent = btn

local btn_stroke = [Link]('UIStroke')

btn_stroke.Color = [Link](45, 45, 45)
btn_stroke.Thickness = 1
btn_stroke.Parent = btn

local indicator = [Link]('Frame')

 [Link] = [Link](0, 3, 0, 20)
[Link] = [Link](0, 6, 0.5, -10)
indicator.BackgroundColor3 = [Link](255, 255, 255)
[Link] = 0
[Link] = false
[Link] = 10
[Link] = btn

local indicator_corner = [Link]('UICorner')

indicator_corner.CornerRadius = [Link](1, 0)
indicator_corner.Parent = indicator

local btn_text = [Link]('TextLabel')

btn_text.Size = [Link](1, -20, 1, 0)
btn_text.Position = [Link](0, 16, 0, 0)
btn_text.BackgroundTransparency = 1
btn_text.Text = curve_data.name
btn_text.Font = [Link]
btn_text.TextSize = 11
btn_text.TextColor3 = [Link](150, 150, 150)
btn_text.TextXAlignment = [Link]
btn_text.ZIndex = 9
btn_text.Parent = btn

buttons[i] = {
button = btn,
stroke = btn_stroke,
text = btn_text,
indicator = indicator,
container = btn_container
}

local touch_start = 0
local was_dragged = false

[Link]:Connect(function(input)
if [Link] == [Link] then
touch_start = tick()
was_dragged = false
end
end)

[Link]:Connect(function(input)
if [Link] == [Link] then
if (tick() - touch_start) > 0.1 then
was_dragged = true
end
end
end)

[Link]:Connect(function(input)
if [Link] == [Link] and not was_dragged
then

for idx, name in ipairs(System.__config.__curve_names) do

if name == curve_data.name then
System.__properties.__curve_mode = idx
AutoCurveDropdown:update(curve_data.name)
break
 end
end

if current_selected then
game:GetService("TweenService"):Create(current_selected.button,
[Link](0.2, [Link]), {
BackgroundColor3 = [Link](20, 20, 20)
}):Play()
game:GetService("TweenService"):Create(current_selected.text,
[Link](0.2, [Link]), {
TextColor3 = [Link](150, 150, 150)
}):Play()
game:GetService("TweenService"):Create(current_selected.stroke,
[Link](0.2, [Link]), {
Color = [Link](45, 45, 45)
}):Play()
current_selected.[Link] = false
end

game:GetService("TweenService"):Create(btn, [Link](0.2,
[Link]), {
BackgroundColor3 = [Link](30, 30, 30)
}):Play()
game:GetService("TweenService"):Create(btn_text, [Link](0.2,
[Link]), {
TextColor3 = [Link](255, 255, 255)
}):Play()
game:GetService("TweenService"):Create(btn_stroke,
[Link](0.2, [Link]), {
Color = [Link](255, 255, 255)
}):Play()
[Link] = true

current_selected = buttons[i]

if getgenv().AutoCurveHotkeyNotify then
[Link]({
title = "AutoCurve",
text = curve_data.name,
duration = 2
})
end
end
end)
end

local is_expanded = true

local expanded_height = 48 + (#CURVE_TYPES * 32) + ((#CURVE_TYPES - 1) * 4) +
12
local minimized_height = 40

buttons_container.Size = [Link](1, -16, 0, (#CURVE_TYPES * 32) +

((#CURVE_TYPES - 1) * 4))
main_frame.Size = [Link](0, 140, 0, expanded_height)

toggle_btn.MouseButton1Click:Connect(function()
is_expanded = not is_expanded
toggle_btn.Text = is_expanded and "−" or "+"
 game:GetService("TweenService"):Create(main_frame, [Link](0.25,
[Link], [Link]), {
Size = [Link](0, 140, 0, is_expanded and expanded_height or
minimized_height)
}):Play()

game:GetService("TweenService"):Create(buttons_container,
[Link](0.25, [Link], [Link]), {
Size = [Link](1, -16, 0, is_expanded and (#CURVE_TYPES * 32) +
((#CURVE_TYPES - 1) * 4) or 0)
}):Play()
end)

local drag_start = nil

local start_pos = nil
local is_dragging = false

[Link]:Connect(function(input)
if [Link] == [Link] or [Link]
== [Link].MouseButton1 then
drag_start = [Link]
start_pos = main_frame.Position
is_dragging = true
end
end)

[Link]:Connect(function(input)
if is_dragging and ([Link] == [Link] or
[Link] == [Link]) then
local delta = [Link] - drag_start
main_frame.Position = [Link](
start_pos.[Link],
start_pos.[Link] + delta.X,
start_pos.[Link],
start_pos.[Link] + delta.Y
)
end
end)

[Link]:Connect(function(input)
if [Link] == [Link] or [Link]
== [Link].MouseButton1 then
is_dragging = false
end
end)

[Link] = CoreGui

return {gui = gui, main_frame = main_frame, buttons = buttons}

end

local CURVE_TYPES = {
{key = [Link], name = "Camera"},
{key = [Link], name = "Random"},
{key = [Link], name = "Accelerated"},
{key = [Link], name = "Backwards"},
{key = [Link], name = "Slow"},
{key = [Link], name = "High"}
}
local function updateCurveType(newType)
for i, name in ipairs(System.__config.__curve_names) do
if name == newType then
System.__properties.__curve_mode = i
AutoCurveDropdown:update(newType)
break
end
end

if getgenv().AutoCurveHotkeyNotify then
[Link]({
title = "AutoCurve",
text = newType,
duration = 2
})
end
end

local hotkeyModule = rage:create_module({

title = "AutoCurve Hotkey" .. (System.__properties.__is_mobile and "(Mobile)"
or "(PC)"),
description = "Press 1-6 to change curve",
flag = "autocurve_hotkey",
section = "left",
callback = function(state)
getgenv().AutoCurveHotkeyEnabled = state

if System.__properties.__is_mobile then
if state then
if not System.__properties.__mobile_guis.curve_selector then
local curve_selector = create_curve_selector_mobile()
System.__properties.__mobile_guis.curve_selector =
curve_selector
end
else

destroy_mobile_gui(System.__properties.__mobile_guis.curve_selector)
System.__properties.__mobile_guis.curve_selector = nil
end
end
end
})

hotkeyModule:create_checkbox({
title = "Notify",
flag = "AutoCurveHotkeyNotify",
callback = function(value)
getgenv().AutoCurveHotkeyNotify = value
end
})

[Link]:Connect(function(input, processed)
if processed or not getgenv().AutoCurveHotkeyEnabled or
System.__properties.__is_mobile then return end

if [Link] == [Link] then

for _, curveData in ipairs(CURVE_TYPES) do
if [Link] == [Link] then
 updateCurveType([Link])
break
end
end
end
end)

--[[local AimPlayer = {}

local state = {
playerNames = {},
playerMap = {},
selectedTarget = nil,
isEnabled = false,
notificationsEnabled = false,
silentSelection = false,
dropdown = nil
}

local config = {
refreshDelay = 0.5,
notificationDuration = 3,
maxOptions = 20
}

local function formatPlayerDisplay(player)

return [Link]("%s (@%s)", [Link] or "Unknown", [Link]
or "Unknown")
end

local function sendNotification(title, text)

if not [Link] then return end

[Link]({
title = title,
text = text,
duration = [Link]
})
end

function [Link]()
[Link]([Link])
[Link]([Link])

for _, player in pairs(Players:GetPlayers()) do

if player ~= LocalPlayer and player:IsDescendantOf(Players) then
local display = formatPlayerDisplay(player)
[Link]([Link], display)
[Link][display] = [Link]
end
end

if #[Link] == 0 then
[Link]([Link], "No Players Available")
end
end

function [Link]()
[Link]()
 if [Link] and typeof([Link].set_options) == "function" then
[Link]:set_options([Link])

if [Link] then
for display, name in pairs([Link]) do
if name == [Link] then
[Link] = true
[Link]:update(display)
[Link] = false
return
end
end

[Link]("Selected player is no longer available")

end
end
end

function [Link](displayString)
if displayString == "No Players Available" then
[Link]()
return
end

local targetName = [Link][displayString]

if not targetName then return end

[Link] = targetName
getgenv().SelectedTarget = targetName

if not [Link] then

sendNotification("Target Player", "Now targeting: " .. displayString)
end
end

function [Link](message)
[Link] = nil
getgenv().SelectedTarget = nil

if message then
sendNotification("Target Player", message)
end
end

function [Link](enabled)
[Link] = enabled
[Link] = enabled
[Link] = [Link] or {}
[Link] = enabled

sendNotification(
"Player Aim Notification",
enabled and "Player Aim has been turned ON" or "Player Aim has been turned
OFF"
)
end

function [Link](enabled)
 [Link] = enabled
getgenv().TargetPlayerNotify = enabled
end

local function onPlayerAdded()

[Link]([Link])
[Link]()
end

local function onPlayerRemoving(player)

[Link]([Link])

if [Link] == [Link] then

[Link]("Selected player left the game")
end

[Link]()
end

[Link]()

local targetModule = rage:create_module({

title = "Player Aim",
description = "Target a specific player only",
flag = "targetplayer",
section = "left",
callback = [Link]
})

targetModule:create_checkbox({
title = "Notify",
flag = "TargetPlayerNotify",
callback = [Link]
})

[Link] = targetModule:create_dropdown({
title = "Select Target",
flag = "TargetPlayerName",
options = [Link],
multi_dropdown = false,
maximum_options = [Link],
callback = [Link]
})

[Link]:Connect(onPlayerAdded)
[Link]:Connect(onPlayerRemoving)

function [Link]()
return [Link]
end

function [Link]()
return [Link]
end

function [Link]()
if not [Link] then return nil end
return Players:FindFirstChild([Link])
end]]
detectionstab:create_module({
title = 'Infinity Detection',
flag = 'Infinity',
description = '',
section = 'left',
callback = function(value)
System.__config.__detections.__infinity = value
end
})

detectionstab:create_module({
title = 'Death Slash Detection',
flag = 'Death_Slash',
description = '',
section = 'right',
callback = function(value)
System.__config.__detections.__deathslash = value
end
})

detectionstab:create_module({
title = 'Time Hole Detection',
flag = 'Time_Hole',
description = '',
section = 'left',
callback = function(value)
System.__config.__detections.__timehole = value
end
})

local slashes_module = detectionstab:create_module({

title = 'Slashes Of Fury Detection',
flag = 'Slashes_Of_Fury',
description = '',
section = 'right',
callback = function(value)
System.__config.__detections.__slashesoffury = value
end
})

slashes_module:create_slider({
title = "Parry Delay",
minimum_value = 0.05,
maximum_value = 0.250,
value = 0.05,
round_number = true,
flag = "parry_delay",
callback = function(value)
parryDelay = value
end
})

slashes_module:create_slider({
title = "Max Parry Count",
minimum_value = 1,
maximum_value = 36,
value = 36,
round_number = true,
 flag = "max_parry_count",
callback = function(value)
maxParryCount = value
end
})

detectionstab:create_module({
title = 'Anti-Phantom [BETA]',
flag = 'Anti_Phantom',
description = '',
section = 'left',
callback = function(value)
System.__config.__detections.__phantom = value
end
})

local manual_spam_module = set:create_module({

title = "Manual Spam",
description = "High-frequency parry spam",
flag = "manualspam",
section = "left",
callback = function(state)
if System.__properties.__is_mobile then
if state then
if not System.__properties.__mobile_guis.manual_spam then
local manual_spam_mobile = create_mobile_button('Spam', 0.8,
[Link](255, 255, 255))
System.__properties.__mobile_guis.manual_spam =
manual_spam_mobile

local manual_touch_start = 0
local manual_was_dragged = false

manual_spam_mobile.[Link]:Connect(function(input)
if [Link] == [Link] then
manual_touch_start = tick()
manual_was_dragged = false
end
end)

manual_spam_mobile.[Link]:Connect(function(input)
if [Link] == [Link] then
if (tick() - manual_touch_start) > 0.1 then
manual_was_dragged = true
end
end
end)

manual_spam_mobile.[Link]:Connect(function(input)
if [Link] == [Link] and not
manual_was_dragged then
System.__properties.__manual_spam_enabled = not
System.__properties.__manual_spam_enabled

if System.__properties.__manual_spam_enabled then
System.manual_spam.start()
manual_spam_mobile.[Link] = "ON"
manual_spam_mobile.text.TextColor3 =
[Link](0, 255, 100)
 else
System.manual_spam.stop()
manual_spam_mobile.[Link] = "Spam"
manual_spam_mobile.text.TextColor3 =
[Link](255, 255, 255)
end

if getgenv().ManualSpamNotify then
[Link]({
title = "ManualSpam",
text =
System.__properties.__manual_spam_enabled and "ON" or "OFF",
duration = 2
})
end
end
end)
end
else
System.__properties.__manual_spam_enabled = false
System.manual_spam.stop()
destroy_mobile_gui(System.__properties.__mobile_guis.manual_spam)
System.__properties.__mobile_guis.manual_spam = nil
end
else
System.__properties.__manual_spam_enabled = state
if state then
System.manual_spam.start()
else
System.manual_spam.stop()
end

if getgenv().ManualSpamNotify then
[Link]({
title = "Manual Spam",
text = state and "ON" or "OFF",
duration = 2
})
end
end
end
})

manual_spam_module:create_checkbox({
title = "Notify",
flag = "ManualSpamNotify",
callback = function(value)
getgenv().ManualSpamNotify = value
end
})

manual_spam_module:create_dropdown({
title = "Mode",
flag = "manualspam_mode",
options = {"Remote", "Keypress"},
default = "Remote",
multi_dropdown = false,
maximum_options = 2,
callback = function(value)
 getgenv().ManualSpamMode = value
end
})

manual_spam_module:create_checkbox({
title = "Animation Fix",
flag = "ManualSpamAnimationFix",
callback = function(value)
getgenv().ManualSpamAnimationFix = value
end
})

manual_spam_module:create_slider({
title = 'Spam Rate',
flag = 'Spam_Rate',
maximum_value = 5000,
minimum_value = 60,
value = 240,
round_number = true,
callback = function(value)
System.__properties.__spam_rate = value
end
})

local auto_spam_module = set:create_module({

title = 'Auto Spam',
flag = 'Auto_Spam_Parry',
description = 'Automatically spam parries ball',
section = 'right',
callback = function(value)
System.__properties.__auto_spam_enabled = value
if value then
System.auto_spam.start()
if getgenv().AutoSpamNotify then
[Link]({
title = "Auto Spam",
text = "ON",
duration = 2
})
end
else
System.auto_spam.stop()
if getgenv().AutoSpamNotify then
[Link]({
title = "Auto Spam",
text = "OFF",
duration = 2
})
end
end
end
})

auto_spam_module:create_checkbox({
title = "Notify",
flag = "Auto_Spam_Notify",
callback = function(value)
getgenv().AutoSpamNotify = value
end
})

auto_spam_module:create_dropdown({
title = "Mode",
flag = "autospam_mode",
options = {"Remote", "Keypress"},
default = "Remote",
multi_dropdown = false,
maximum_options = 2,
callback = function(value)
getgenv().AutoSpamMode = value
end
})

auto_spam_module:create_checkbox({
title = "Animation Fix",
flag = "AutoSpamAnimationFix",
callback = function(value)
getgenv().AutoSpamAnimationFix = value
end
})

auto_spam_module:create_slider({
title = "Parry Threshold",
flag = "Parry_Threshold",
maximum_value = 5,
minimum_value = 1,
value = 2.5,
round_number = false,
callback = function(value)
System.__properties.__spam_threshold = value
end
})

-- Versão reforçada do Avatar Changer (mantive o modelo do script e assinaturas)

local __players = cloneref(game:GetService('Players'))
local __localplayer = __players.LocalPlayer

local __flags = {}
local __currentDesc = nil
local __targetUserId = nil
local __persistent_tasks = {} -- index por Character para coroutines/threads de
reaplicação

-- Função utilitária para comparar se a descrição aplicada parece OK

-- Não existe comparação perfeita, mas checamos algumas propriedades chave
(Shirt/Pants/Graphic)
local function __descriptions_match(a, b)
if not a or not b then return false end
-- Compara algumas propriedades comumente usadas
local keys = {"Shirt", "Pants", "ShirtGraphic", "Head", "Face",
"BodyTypeScale", "HeightScale", "WidthScale", "DepthScale", "ProportionScale"}
for _,k in ipairs(keys) do
local av = a[k]
local bv = b[k]
if (av ~= nil and bv ~= nil) and tostring(av) ~= tostring(bv) then
return false
end
end
 return true
end

-- APLICAÇÃO EXTREMAMENTE FORÇADA – várias estratégias

local function __force_apply_brutal(hum, desc)
if not hum or not desc then return false end

-- 0) Tenta aplicar diretamente algumas vezes rápidas

for _ = 1, 20 do
pcall(function()
hum:ApplyDescriptionClientServer(desc)
end)
[Link](0.05)
local applied = nil
pcall(function() applied = hum:GetAppliedDescription() end)
if applied and __descriptions_match(applied, desc) then
return true
end
end

-- 1) Reset suave e tentar de novo

pcall(function()
[Link] = [Link]("HumanoidDescription")
end)
[Link](0.1)

for _ = 1, 20 do
pcall(function()
hum:ApplyDescriptionClientServer(desc)
end)
[Link](0.05)
local applied = nil
pcall(function() applied = hum:GetAppliedDescription() end)
if applied and __descriptions_match(applied, desc) then
return true
end
end

-- 2) Tenta recriar humanoid se houver HumanoidRootPart (substituição forçada)

local parent = [Link]
local root = parent and parent:FindFirstChild("HumanoidRootPart")
if root and parent then
local old = hum
local success, newHum = pcall(function()
local nh = [Link]("Humanoid")
[Link] = "Humanoid"
[Link] = parent
return nh
end)
[Link](0.05)
if success and newHum then
-- Destrói o antigo para forçar atualização de character
pcall(function() old:Destroy() end)
hum = newHum
[Link](0.05)
end
end

-- 3) Última onda de tentativas estendidas

 for _ = 1, 80 do
pcall(function()
hum:ApplyDescriptionClientServer(desc)
end)
[Link](0.05)
local applied = nil
pcall(function() applied = hum:GetAppliedDescription() end)
if applied and __descriptions_match(applied, desc) then
return true
end
end

return false
end

local function __apparence(__name)

local s, e = pcall(function()
local __id = __players:GetUserIdFromNameAsync(__name)
return __players:GetHumanoidDescriptionFromUserId(__id), __id
end)

if not s then
return nil, nil
end

return e -- e is actually two return values if successful

end

-- Inicia um loop persistente que reaplica a descrição enquanto o flag estiver

ativo
local function __start_persistent_reapply(character, desc)
if not character or not desc then return end
local charKey = character
-- Se já existe tarefa persistente para esse char, não crie outra
if __persistent_tasks[charKey] then return end

local stop = false

__persistent_tasks[charKey] = {
stop = function() stop = true end
}

spawn(function()
-- procura humanoid (pode demorar)
local hum = character:FindFirstChildOfClass("Humanoid") or
character:WaitForChild("Humanoid", 5)
if not hum then
__persistent_tasks[charKey] = nil
return
end

-- Se o humanoid for substituído, reativa a tentativa (escuta

[Link]/[Link])
local conn
conn = hum:GetPropertyChangedSignal("Parent"):Connect(function()
if not [Link] then
-- humanoid removido, finaliza e espera novo humanoid
if conn then conn:Disconnect() end
end
end)
 -- Loop principal: tenta forçar, depois reaplica periodicamente
while not stop and [Link] do
-- aplica brutalmente uma vez
pcall(function()
__force_apply_brutal(hum, desc)
end)

-- checa se aplicado corretamente

local applied = nil
pcall(function() applied = hum:GetAppliedDescription() end)
if applied and __descriptions_match(applied, desc) then
-- boa aplicação; aguarda mais tempo antes de verificar novamente
for i = 1, 40 do
if stop or not [Link] then break end
[Link](0.25)
end
else
-- não aplicou corretamente -> aumentar frequência de tentativas
for i = 1, 20 do
if stop or not [Link] then break end
pcall(function()
hum:ApplyDescriptionClientServer(desc)
end)
[Link](0.1)
pcall(function() applied = hum:GetAppliedDescription() end)
if applied and __descriptions_match(applied, desc) then break
end
end
end

-- Se humanoid foi destruído e substituído, atualiza referência

if not [Link] or not [Link]:IsDescendantOf(game) then
hum = character:FindFirstChildOfClass("Humanoid") or
character:WaitForChild("Humanoid", 5)
end
end

-- cleanup
if conn then pcall(function() conn:Disconnect() end) end
__persistent_tasks[charKey] = nil
end)
end

local function __stop_all_persistent()

for k,v in pairs(__persistent_tasks) do
if v and type([Link]) == "function" then
pcall([Link])
end
__persistent_tasks[k] = nil
end
end

local function __set(__name, __char)

if not __name or __name == '' then
return
end

local __hum = __char and __char:WaitForChild('Humanoid', 5)

 if not __hum then
return
end

local success, __desc, __id = pcall(function()

local id = __players:GetUserIdFromNameAsync(__name)
local desc = __players:GetHumanoidDescriptionFromUserId(id)
return desc, id
end)

if not success or not __desc then

warn("Failed to get appearance for: " .. tostring(__name))
return
end

-- Guarda alvo atual

__currentDesc = __desc
__targetUserId = __id

-- LIMPA TUDO localmente (mantendo seu comportamento)

pcall(function()
__localplayer:ClearCharacterAppearance()
__hum.Description = [Link]("HumanoidDescription")
end)

[Link](0.05)

-- APLICAÇÃO IMPOSSÍVEL DE FALHAR (tentativa imediata e depois persistente)

pcall(function()
__force_apply_brutal(__hum, __desc)
end)

-- Inicia reaplicação persistente para cobrir respawn/humanoid

reset/substituição
__start_persistent_reapply(__char, __desc)
end

local module = pl:create_module({

title = 'Avatar Changer',
flag = 'AvatarChanger',
description = 'Change your avatar to another player',
section = 'left',
callback = function(val)
__flags['Skin Changer'] = val

if val then
local __char = __localplayer.Character

if __char and __flags['name'] then

__set(__flags['name'], __char)
end

-- Conectar CharacterAdded para reaplicar sempre no spawn/respawn

__flags['loop'] = __localplayer.CharacterAdded:Connect(function(char)
[Link](0.05)
if __flags['name'] then
__set(__flags['name'], char)
end
 end)
else
-- Desligando: desconectar e tentar restaurar skin local
if __flags['loop'] then
__flags['loop']:Disconnect()
__flags['loop'] = nil

-- Para tarefas persistentes

__stop_all_persistent()

local __char = __localplayer.Character

if __char then
-- Restaura a aparência original do próprio jogador
pcall(function()
__localplayer:ClearCharacterAppearance()
-- tenta reaplicar descrição padrão do usuário
local ok, desc = pcall(function()
return
__players:GetHumanoidDescriptionFromUserId(__localplayer.UserId)
end)
if ok and desc then
local hum = __char:FindFirstChildOfClass("Humanoid") or
__char:WaitForChild("Humanoid", 3)
if hum then
hum:ApplyDescriptionClientServer(desc)
end
end
end)
end
end
end
end
})

module:create_textbox({
title = "Target Username",
placeholder = "Enter Username...",
flag = "AvatarChangerTextbox",
callback = function(val: string)
__flags['name'] = val

if __flags['Skin Changer'] and val ~= '' then

local __char = __localplayer.Character
if __char then
__set(val, __char)
end
end
end
})

local function create_animation(object, info, value)

local animation = game:GetService('TweenService'):Create(object, info, value)
animation:Play()
[Link]([Link])
animation:Destroy()
end

local animation_system = {
 storage = {},
current = nil,
track = nil
}

function animation_system.load_animations()
local emotes_folder = game:GetService("ReplicatedStorage").[Link]

for _, animation in pairs(emotes_folder:GetChildren()) do

if animation:IsA("Animation") and animation:GetAttribute("EmoteName") then
local emote_name = animation:GetAttribute("EmoteName")
animation_system.storage[emote_name] = animation
end
end
end

function animation_system.get_emotes_list()
local emotes_list = {}

for emote_name in pairs(animation_system.storage) do

[Link](emotes_list, emote_name)
end

[Link](emotes_list)
return emotes_list
end

function animation_system.play(emote_name)
local animation_data = animation_system.storage[emote_name]

if not animation_data or not [Link] then

return false
end

local humanoid = [Link]:FindFirstChild("Humanoid")

if not humanoid then
return false
end

local animator = humanoid:FindFirstChild("Animator")

if not animator then
return false
end

if animation_system.track then
animation_system.track:Stop()
animation_system.track:Destroy()
end

animation_system.track = animator:LoadAnimation(animation_data)
animation_system.track:Play()
animation_system.current = emote_name

return true
end

function animation_system.stop()
if animation_system.track then
animation_system.track:Stop()
 animation_system.track:Destroy()
animation_system.track = nil
end
animation_system.current = nil
end

function animation_system.start()
if not System.__properties.__connections.animations then
System.__properties.__connections.animations =
[Link]:Connect(function()
if not [Link] or not [Link]
then
return
end

local speed =
[Link]

if speed > 30 and getgenv().AutoStop then

if animation_system.track and animation_system.[Link] then
animation_system.track:Stop()
end
else
if animation_system.current and (not animation_system.track or not
animation_system.[Link]) then
animation_system.play(animation_system.current)
end
end
end)
end
end

function animation_system.cleanup()
animation_system.stop()

if System.__properties.__connections.animations then
System.__properties.__connections.animations:Disconnect()
System.__properties.__connections.animations = nil
end
end

animation_system.load_animations()
local emotes_data = animation_system.get_emotes_list()
local selected_animation = emotes_data[1]

local animations_module = pl:create_module({

title = 'Emotes',
flag = 'Emotes',
description = 'Custom Emotes',
section = 'right',
callback = function(value)
getgenv().Animations = value

if value then
animation_system.start()

if selected_animation then
animation_system.play(selected_animation)
end
 else
animation_system.cleanup()
end
end
})

animations_module:create_checkbox({
title = "Auto Stop",
flag = "AutoStop",
callback = function(value)
getgenv().AutoStop = value
end
})

local animation_dropdown = animations_module:create_dropdown({

title = 'Emote Type',
flag = 'Selected_Animation',
options = emotes_data,
multi_dropdown = false,
maximum_options = 10,
callback = function(value)
selected_animation = value

if getgenv().Animations then
animation_system.play(value)
end
end
})

animation_dropdown:update(selected_animation)

local CameraToggle = pl:create_module({

title = 'FOV',
flag = 'FOV',

description = 'Changes Camera POV',

section = 'left',

callback = function(value)
getgenv().CameraEnabled = value
local Camera = game:GetService("Workspace").CurrentCamera

if value then
getgenv().CameraFOV = getgenv().CameraFOV or 70
[Link] = getgenv().CameraFOV

if not getgenv().FOVLoop then

getgenv().FOVLoop =
game:GetService("RunService").RenderStepped:Connect(function()
if getgenv().CameraEnabled then
[Link] = getgenv().CameraFOV
end
end)
end
else
[Link] = 70

if getgenv().FOVLoop then
getgenv().FOVLoop:Disconnect()
 getgenv().FOVLoop = nil
end
end
end
})

CameraToggle:create_slider({
title = 'Camera FOV',
flag = 'Camera_FOV',

maximum_value = 120,
minimum_value = 50,
value = 70,

round_number = true,

callback = function(value)
getgenv().CameraFOV = value
if getgenv().CameraEnabled then
game:GetService("Workspace").[Link] = value
end
end
})

local CharacterModifier = pl:create_module({

title = 'Character',
flag = 'CharacterModifier',
description = 'Changes various character properties',
section = 'right',

callback = function(value)
getgenv().CharacterModifierEnabled = value

if value then
if not getgenv().CharacterConnection then
getgenv().OriginalValues = {}
getgenv().spinAngle = 0

getgenv().CharacterConnection =
[Link]:Connect(function()
local char = [Link]
if not char then return end

local humanoid = char:FindFirstChild("Humanoid")

local root = char:FindFirstChild("HumanoidRootPart")

if humanoid then
if not getgenv().[Link] then
getgenv().[Link] = [Link]
getgenv().[Link] = [Link]
getgenv().[Link] =
[Link]
getgenv().[Link] = [Link]
getgenv().[Link] =
[Link]
end

if getgenv().WalkspeedCheckboxEnabled then
[Link] = getgenv().CustomWalkSpeed or 36
 end

if getgenv().JumpPowerCheckboxEnabled then
if [Link] then
[Link] = getgenv().CustomJumpPower or
50
else
[Link] = getgenv().CustomJumpHeight or
7.2
end
end

if getgenv().HipHeightCheckboxEnabled then
[Link] = getgenv().CustomHipHeight or 0
end

if getgenv().SpinbotCheckboxEnabled and root then

[Link] = false
getgenv().spinAngle = (getgenv().spinAngle +
(getgenv().CustomSpinSpeed or 5)) % 360
[Link] = [Link]([Link]) *
[Link](0, [Link](getgenv().spinAngle), 0)
else
if getgenv().[Link] ~= nil then
[Link] =
getgenv().[Link]
end
end
end

if getgenv().GravityCheckboxEnabled and getgenv().CustomGravity

then
[Link] = getgenv().CustomGravity
end
end)
end
else
if getgenv().CharacterConnection then
getgenv().CharacterConnection:Disconnect()
getgenv().CharacterConnection = nil

local char = [Link]

if char then
local humanoid = char:FindFirstChild("Humanoid")

if humanoid and getgenv().OriginalValues then

[Link] = getgenv().[Link] or
16
if [Link] then
[Link] = getgenv().[Link]
or 50
else
[Link] =
getgenv().[Link] or 7.2
end
[Link] = getgenv().[Link] or
0
[Link] = getgenv().[Link]
or true
 end
end

[Link] = 196.2

if getgenv().InfiniteJumpConnection then
getgenv().InfiniteJumpConnection:Disconnect()
getgenv().InfiniteJumpConnection = nil
end

getgenv().OriginalValues = nil
getgenv().spinAngle = nil
end
end
end
})

CharacterModifier:create_checkbox({
title = "Infinite Jump",
flag = "InfiniteJumpCheckbox",
callback = function(value)
getgenv().InfiniteJumpCheckboxEnabled = value

if value and getgenv().CharacterModifierEnabled then

if not getgenv().InfiniteJumpConnection then
getgenv().InfiniteJumpConnection =
[Link]:Connect(function()
if getgenv().InfiniteJumpCheckboxEnabled and
getgenv().CharacterModifierEnabled then
local char = [Link]
if char and char:FindFirstChild("Humanoid") then

[Link]:ChangeState([Link])
end
end
end)
end
else
if getgenv().InfiniteJumpConnection then
getgenv().InfiniteJumpConnection:Disconnect()
getgenv().InfiniteJumpConnection = nil
end
end
end
})

CharacterModifier:create_divider({})

CharacterModifier:create_checkbox({
title = "Spin",
flag = "SpinbotCheckbox",
callback = function(value)
getgenv().SpinbotCheckboxEnabled = value

if not value and getgenv().CharacterModifierEnabled then

local char = [Link]
if char and char:FindFirstChild("Humanoid") and
getgenv().OriginalValues then
[Link] = getgenv().[Link] or
true
end
end
end
})

CharacterModifier:create_slider({
title = 'Spin Speed',
flag = 'CustomSpinSpeed',
maximum_value = 50,
minimum_value = 1,
value = 5,
round_number = true,

callback = function(value)
getgenv().CustomSpinSpeed = value
end
})

CharacterModifier:create_divider({})

CharacterModifier:create_checkbox({
title = "Walk Speed",
flag = "WalkspeedCheckbox",
callback = function(value)
getgenv().WalkspeedCheckboxEnabled = value

if not value and getgenv().CharacterModifierEnabled then

local char = [Link]
if char and char:FindFirstChild("Humanoid") and
getgenv().OriginalValues then
[Link] = getgenv().[Link] or 16
end
end
end
})

CharacterModifier:create_slider({
title = 'Walk Speed Value',
flag = 'CustomWalkSpeed',
maximum_value = 500,
minimum_value = 16,
value = 36,
round_number = true,

callback = function(value)
getgenv().CustomWalkSpeed = value

if getgenv().CharacterModifierEnabled and
getgenv().WalkspeedCheckboxEnabled then
local char = [Link]
if char and char:FindFirstChild("Humanoid") then
[Link] = value
end
end
end
})

CharacterModifier:create_divider({})
CharacterModifier:create_checkbox({
title = "Jump Power",
flag = "JumpPowerCheckbox",
callback = function(value)
getgenv().JumpPowerCheckboxEnabled = value

if not value and getgenv().CharacterModifierEnabled then

local char = [Link]
if char and char:FindFirstChild("Humanoid") and
getgenv().OriginalValues then
local humanoid = [Link]
if [Link] then
[Link] = getgenv().[Link] or 50
else
[Link] = getgenv().[Link] or
7.2
end
end
end
end
})

CharacterModifier:create_slider({
title = 'Jump Power Value',
flag = 'CustomJumpPower',
maximum_value = 200,
minimum_value = 50,
value = 50,
round_number = true,

callback = function(value)
getgenv().CustomJumpPower = value
getgenv().CustomJumpHeight = value * 0.144

if getgenv().CharacterModifierEnabled and
getgenv().JumpPowerCheckboxEnabled then
local char = [Link]
if char and char:FindFirstChild("Humanoid") then
local humanoid = [Link]
if [Link] then
[Link] = value
else
[Link] = value * 0.144
end
end
end
end
})

CharacterModifier:create_divider({})

CharacterModifier:create_checkbox({
title = "Gravity",
flag = "GravityCheckbox",
callback = function(value)
getgenv().GravityCheckboxEnabled = value

if not value and getgenv().CharacterModifierEnabled then

 [Link] = 196.2
end
end
})

CharacterModifier:create_slider({
title = 'Gravity Value',
flag = 'CustomGravity',
maximum_value = 400.0,
minimum_value = 0,
value = 196.2,
round_number = true,

callback = function(value)
getgenv().CustomGravity = value

if getgenv().CharacterModifierEnabled and getgenv().GravityCheckboxEnabled

then
[Link] = value
end
end
})

CharacterModifier:create_divider({})

CharacterModifier:create_checkbox({
title = "Hip Height",
flag = "HipHeightCheckbox",
callback = function(value)
getgenv().HipHeightCheckboxEnabled = value

if not value and getgenv().CharacterModifierEnabled then

local char = [Link]
if char and char:FindFirstChild("Humanoid") and
getgenv().OriginalValues then
[Link] = getgenv().[Link] or 0
end
end
end
})

CharacterModifier:create_slider({
title = 'Hip Height Value',
flag = 'CustomHipHeight',
maximum_value = 20,
minimum_value = -5,
value = 0,
round_number = true,

callback = function(value)
getgenv().CustomHipHeight = value

if getgenv().CharacterModifierEnabled and
getgenv().HipHeightCheckboxEnabled then
local char = [Link]
if char and char:FindFirstChild("Humanoid") then
[Link] = value
end
end
 end
})

local ability_esp = {
__config = {
gui_name = "AbilityESPGui",
gui_size = [Link](0, 200, 0, 40),
studs_offset = [Link](0, 3.2, 0),
text_color = [Link](255, 255, 255),
stroke_color = [Link](0, 0, 0),
font = [Link],
text_size = 14,
update_rate = 1/30
},

__state = {
active = false,
players = {},
update_task = nil
}
}

function ability_esp.create_billboard(player)
local character = [Link]
if not character or not [Link] then
return nil
end

local humanoid = character:FindFirstChild("Humanoid")

if not humanoid then
return nil
end

local head = character:FindFirstChild("Head")

if not head then
return nil
end

local existing = head:FindFirstChild(ability_esp.__config.gui_name)

if existing then
existing:Destroy()
end

local billboard = [Link]("BillboardGui")

[Link] = ability_esp.__config.gui_name
[Link] = head
[Link] = ability_esp.__config.gui_size
[Link] = ability_esp.__config.studs_offset
[Link] = true
[Link] = head

local label = [Link]("TextLabel")

[Link] = [Link](1, 0, 1, 0)
[Link] = 1
label.TextColor3 = ability_esp.__config.text_color
label.TextStrokeColor3 = ability_esp.__config.stroke_color
[Link] = 0.5
[Link] = ability_esp.__config.font
[Link] = ability_esp.__config.text_size
 [Link] = true
[Link] = [Link]
[Link] = [Link]
[Link] = billboard

[Link] = [Link]

return label, billboard

end

function ability_esp.update_label(player, label)

if not player or not [Link] or not label or not [Link] then
return false
end

local character = [Link]

if not character or not [Link] or not
character:FindFirstChild("Humanoid") then
return false
end

if ability_esp.__state.active then
[Link] = true
local ability_name = player:GetAttribute("EquippedAbility")
[Link] = ability_name and
([Link] .. " [" .. ability_name .. "]") or
[Link]
else
[Link] = false
end

return true
end

function ability_esp.setup_character(player)
if not ability_esp.__state.active then
return
end

[Link](0.1)

local character = [Link]

if not character or not [Link] or not
character:FindFirstChild("Humanoid") then
return
end

local label, billboard = ability_esp.create_billboard(player)

if not label then
return
end

if not ability_esp.__state.players[player] then

ability_esp.__state.players[player] = {}
end

ability_esp.__state.players[player].label = label
ability_esp.__state.players[player].billboard = billboard
ability_esp.__state.players[player].character = character
 local char_connection = [Link]:Connect(function()
if not [Link] then
if ability_esp.__state.players[player] then
if ability_esp.__state.players[player].billboard then
ability_esp.__state.players[player].billboard:Destroy()
end
ability_esp.__state.players[player].label = nil
ability_esp.__state.players[player].billboard = nil
ability_esp.__state.players[player].character = nil
end
end
end)

if not System.__properties.__connections.ability_esp then

System.__properties.__connections.ability_esp = {}
end

if not System.__properties.__connections.ability_esp[player] then

System.__properties.__connections.ability_esp[player] = {}
end

System.__properties.__connections.ability_esp[player].char_removing =
char_connection
end

function ability_esp.add_player(player)
if player == LocalPlayer then
return
end

if ability_esp.__state.players[player] then
ability_esp.remove_player(player)
end

if not System.__properties.__connections.ability_esp then

System.__properties.__connections.ability_esp = {}
end

if not System.__properties.__connections.ability_esp[player] then

System.__properties.__connections.ability_esp[player] = {}
end

local char_added_connection = [Link]:Connect(function()

ability_esp.setup_character(player)
end)

System.__properties.__connections.ability_esp[player].char_added =
char_added_connection

if [Link] then
[Link](function()
ability_esp.setup_character(player)
end)
end
end

function ability_esp.remove_player(player)
if System.__properties.__connections.ability_esp and
System.__properties.__connections.ability_esp[player] then
for _, connection in
pairs(System.__properties.__connections.ability_esp[player]) do
if connection and [Link] then
connection:Disconnect()
end
end
System.__properties.__connections.ability_esp[player] = nil
end

local player_data = ability_esp.__state.players[player]

if player_data then
if player_data.billboard then
player_data.billboard:Destroy()
end
ability_esp.__state.players[player] = nil
end
end

function ability_esp.update_loop()
while ability_esp.__state.active do
[Link](ability_esp.__config.update_rate)

local players_to_remove = {}

for player, player_data in pairs(ability_esp.__state.players) do

if not player or not [Link] then
[Link](players_to_remove, player)
continue
end

local character = [Link]

if not character or not [Link] or not
character:FindFirstChild("Humanoid") then
if player_data.billboard then
player_data.billboard:Destroy()
player_data.billboard = nil
player_data.label = nil
end
continue
end

if not player_data.billboard or not player_data.label then

local label, billboard = ability_esp.create_billboard(player)
if label then
player_data.label = label
player_data.billboard = billboard
player_data.character = character
end
end

if player_data.label then
local success = ability_esp.update_label(player, player_data.label)
if not success then
local label, billboard = ability_esp.create_billboard(player)
if label then
player_data.label = label
player_data.billboard = billboard
player_data.character = character
 end
end
end
end

for _, player in ipairs(players_to_remove) do

if ability_esp.__state.players[player] then
if ability_esp.__state.players[player].billboard then
ability_esp.__state.players[player].billboard:Destroy()
end
ability_esp.__state.players[player] = nil
end
end
end
end

function ability_esp.start()
if ability_esp.__state.active then
return
end

ability_esp.__state.active = true
getgenv().AbilityESP = true

for _, player in pairs(Players:GetPlayers()) do

if player ~= LocalPlayer then
ability_esp.add_player(player)
end
end

if not System.__properties.__connections.ability_esp then

System.__properties.__connections.ability_esp = {}
end

System.__properties.__connections.ability_esp.player_added =
[Link]:Connect(function(player)
if ability_esp.__state.active and player ~= LocalPlayer then
[Link](1)
ability_esp.add_player(player)
end
end)

ability_esp.__state.update_task = [Link](function()
ability_esp.update_loop()
end)
end

function ability_esp.stop()
if not ability_esp.__state.active then
return
end

ability_esp.__state.active = false
getgenv().AbilityESP = false

if ability_esp.__state.update_task then
[Link](ability_esp.__state.update_task)
ability_esp.__state.update_task = nil
end
 if System.__properties.__connections.ability_esp then
for player, connections in
pairs(System.__properties.__connections.ability_esp) do
if type(connections) == "table" then
for _, connection in pairs(connections) do
if connection and [Link] then
connection:Disconnect()
end
end
elseif connections and [Link] then
connections:Disconnect()
end
end

System.__properties.__connections.ability_esp = nil
end

for player in pairs(ability_esp.__state.players) do

ability_esp.remove_player(player)
end
end

function ability_esp.toggle(value)
if value then
ability_esp.start()
else
ability_esp.stop()
end
end

visuals:create_module({
title = 'Ability ESP',
flag = 'AbilityESP',
description = 'Displays Player Abilities',
section = 'left',
callback = function(value)
ability_esp.toggle(value)
end
})

local HttpService = game:GetService("HttpService")

local UserInputService = game:GetService("UserInputService")

local save_folder = workspace:FindFirstChild("OwO") or [Link]("Folder",

workspace)
save_folder.Name = "OwO"

local function load_pos()

local file = save_folder:FindFirstChild("ball_ui_pos")
if not file then return nil end

local ok, data = pcall(function()

return HttpService:JSONDecode([Link])
end)

if ok and data and data.x and data.y then

return [Link](0, data.x, 0, data.y)
end
 return nil
end

local function save_pos(udim)

local data = {
x = [Link],
y = [Link]
}

local json = HttpService:JSONEncode(data)

local file = save_folder:FindFirstChild("ball_ui_pos") or

[Link]("StringValue", save_folder)
[Link] = "ball_ui_pos"
[Link] = json
end

local ball_velocity = {
__config = {
gui_name = "BallStatsGui",
colors = {
background = [Link](18, 18, 18),
container = [Link](28, 28, 28),
header = [Link](12, 12, 12),
text_primary = [Link](255, 255, 255),
text_secondary = [Link](170, 170, 170),
accent_green = [Link](34, 197, 94),
accent_orange = [Link](249, 115, 22),
border = [Link](40, 40, 40)
}
},

__state = {
active = false,
gui = nil,
ball_data = {},
is_dragging = false
}
}

function ball_velocity.create_corner(radius)
local corner = [Link]("UICorner")
[Link] = [Link](0, radius or 8)
return corner
end

function ball_velocity.create_stroke(thickness, color)

local stroke = [Link]("UIStroke")
[Link] = thickness or 1
[Link] = color or ball_velocity.__config.[Link]
return stroke
end

function ball_velocity.create_gui()
local gui = [Link]("ScreenGui")
[Link] = ball_velocity.__config.gui_name
[Link] = false
 [Link] = [Link]
[Link] = LocalPlayer:WaitForChild("PlayerGui")

local main_frame = [Link]("Frame")

main_frame.Name = "MainFrame"
main_frame.Size = [Link](0, 180, 0, 95)
main_frame.Position = load_pos() or [Link](0, 20, 0, 150)
main_frame.BackgroundColor3 = ball_velocity.__config.[Link]
main_frame.BorderSizePixel = 0
main_frame.Parent = gui

ball_velocity.create_corner(10).Parent = main_frame
ball_velocity.create_stroke(1, ball_velocity.__config.[Link]).Parent =
main_frame

local header = [Link]("Frame")

[Link] = "Header"
[Link] = [Link](1, 0, 0, 26)
[Link] = [Link](0, 0, 0, 0)
header.BackgroundColor3 = ball_velocity.__config.[Link]
[Link] = 0
[Link] = main_frame

ball_velocity.create_corner(10).Parent = header

local title = [Link]("TextLabel")

[Link] = "Title"
[Link] = [Link](1, -12, 1, 0)
[Link] = [Link](0, 12, 0, 0)
[Link] = 1
[Link] = "Ball Stats"
title.TextColor3 = ball_velocity.__config.colors.text_primary
[Link] = 13
[Link] = [Link]
[Link] = [Link]
[Link] = header

local content = [Link]("Frame")

[Link] = "Content"
[Link] = [Link](1, -18, 1, -34)
[Link] = [Link](0, 9, 0, 30)
[Link] = 1
[Link] = main_frame

local current_label = [Link]("TextLabel")

current_label.Name = "CurrentLabel"
current_label.Size = [Link](1, 0, 0, 14)
current_label.Position = [Link](0, 0, 0, 2)
current_label.BackgroundTransparency = 1
current_label.Text = "Current"
current_label.TextColor3 = ball_velocity.__config.colors.text_secondary
current_label.TextSize = 10
current_label.Font = [Link]
current_label.TextXAlignment = [Link]
current_label.Parent = content

local current_value = [Link]("TextLabel")

current_value.Name = "CurrentValue"
current_value.Size = [Link](1, 0, 0, 20)
current_value.Position = [Link](0, 0, 0, 14)
current_value.BackgroundTransparency = 1
current_value.Text = "0.0"
current_value.TextColor3 = ball_velocity.__config.colors.accent_green
current_value.TextSize = 16
current_value.Font = [Link]
current_value.TextXAlignment = [Link]
current_value.Parent = content

local peak_label = [Link]("TextLabel")

peak_label.Name = "PeakLabel"
peak_label.Size = [Link](1, 0, 0, 14)
peak_label.Position = [Link](0, 0, 0, 36)
peak_label.BackgroundTransparency = 1
peak_label.Text = "Peak"
peak_label.TextColor3 = ball_velocity.__config.colors.text_secondary
peak_label.TextSize = 10
peak_label.Font = [Link]
peak_label.TextXAlignment = [Link]
peak_label.Parent = content

local peak_value = [Link]("TextLabel")

peak_value.Name = "PeakValue"
peak_value.Size = [Link](1, 0, 0, 20)
peak_value.Position = [Link](0, 0, 0, 50)
peak_value.BackgroundTransparency = 1
peak_value.Text = "0.0"
peak_value.TextColor3 = ball_velocity.__config.colors.accent_orange
peak_value.TextSize = 16
peak_value.Font = [Link]
peak_value.TextXAlignment = [Link]
peak_value.Parent = content

local drag_start, start_pos

[Link]:Connect(function(input)
if [Link] == [Link].MouseButton1
or [Link] == [Link] then

ball_velocity.__state.is_dragging = true
drag_start = [Link]
start_pos = main_frame.Position
end
end)

[Link]:Connect(function(input)
if ball_velocity.__state.is_dragging and
([Link] == [Link]
or [Link] == [Link]) then

local delta = [Link] - drag_start

local newpos = [Link](
start_pos.[Link], start_pos.[Link] + delta.X,
start_pos.[Link], start_pos.[Link] + delta.Y
)

main_frame.Position = newpos
end
 end)

[Link]:Connect(function(input)
if [Link] == [Link].MouseButton1
or [Link] == [Link] then

ball_velocity.__state.is_dragging = false
save_pos(main_frame.Position)
end
end)

return gui, current_value, peak_value

end

function ball_velocity.start()
if ball_velocity.__state.active then return end

ball_velocity.__state.active = true
ball_velocity.__state.ball_data = {}

local gui, current_value, peak_value = ball_velocity.create_gui()

ball_velocity.__state.gui = gui

System.__properties.__connections.ball_velocity =
[Link]:Connect(function()

local ball = [Link]()

if not ball then

current_value.Text = "0.0"
peak_value.Text = "0.0"
return
end

local zoomies = ball:FindFirstChild("zoomies")

if not zoomies then
current_value.Text = "0.0"
return
end

local velocity = [Link]

ball_velocity.__state.ball_data[ball] =
ball_velocity.__state.ball_data[ball] or 0

if velocity > ball_velocity.__state.ball_data[ball] then

ball_velocity.__state.ball_data[ball] = velocity
end

current_value.Text = [Link]("%.1f", velocity)

peak_value.Text = [Link]("%.1f",
ball_velocity.__state.ball_data[ball])
end)
end

function ball_velocity.stop()
if not ball_velocity.__state.active then return end

ball_velocity.__state.active = false
 if System.__properties.__connections.ball_velocity then
System.__properties.__connections.ball_velocity:Disconnect()
System.__properties.__connections.ball_velocity = nil
end

if ball_velocity.__state.gui then
ball_velocity.__state.gui:Destroy()
ball_velocity.__state.gui = nil
end

ball_velocity.__state.ball_data = {}
end

visuals:create_module({
title = "Show Ball Velocity",
description = "",
flag = "ballvelocity",
section = "right",
callback = function(state)
if state then
ball_velocity.start()
else
ball_velocity.stop()
end
end
})

local Connections_Manager = {}

local No_Render = misc:create_module({

title = 'No Render',
flag = 'No_Render',
description = 'Disables rendering of effects',
section = 'left',

callback = function(state)
[Link] = state

if state then
Connections_Manager['No Render'] =
[Link]:Connect(function(Value)
Debris:AddItem(Value, 0)
end)
else
if Connections_Manager['No Render'] then
Connections_Manager['No Render']:Disconnect()
Connections_Manager['No Render'] = nil
end
end
end
})

No_Render:change_state(false)

--[[local ParticleSystem = {
Particles = {},
MaxParticles = 5000,
SpawnArea = 500,
 FallSpeed = 25,
SpawnHeight = 100,
SpawnRate = 3,
ParticleColor = [Link](100, 200, 255),
Enabled = false
}

local ParticleFolder = [Link]("Folder")

[Link] = "MagicalParticles"
[Link] = Workspace

local Particles = {}

function [Link]()
local particle = [Link]("Part")
[Link] = "MagicalParticle"
[Link] = [Link](0.9, 0.9, 0.9)
[Link] = [Link]
[Link] = [Link]
[Link] = [Link]
[Link] = false
[Link] = true
[Link] = 0
[Link] = false
[Link] = ParticleFolder

local light = [Link]("PointLight")

[Link] = 2.5
[Link] = 10
[Link] = [Link]
[Link] = particle

local trail = [Link]("Trail")

[Link] = 0.5
[Link] = 0.1
[Link] = true
[Link] = 0.8
[Link] = [Link]([Link])
[Link] = [Link]({
[Link](0, 0.4),
[Link](1, 1)
})
[Link] = [Link]({
[Link](0, 1),
[Link](1, 0)
})

local attachment0 = [Link]("Attachment")

[Link] = particle
local attachment1 = [Link]("Attachment")
[Link] = particle
[Link] = [Link](0, -0.6, 0)

trail.Attachment0 = attachment0
trail.Attachment1 = attachment1
[Link] = particle

return particle
end
function Particles.get_player_position()
local character = [Link]
if character and character:FindFirstChild("HumanoidRootPart") then
return [Link]
end
return [Link]
end

function [Link]()
if not [Link] then return end
if #[Link] >= [Link] then return end

local player_pos = Particles.get_player_position()

local random_x = player_pos.X + [Link](-[Link],
[Link])
local random_z = player_pos.Z + [Link](-[Link],
[Link])
local spawn_y = player_pos.Y + [Link]

local particle = [Link]()

[Link] = [Link](random_x, spawn_y, random_z)

local particle_data = {
Part = particle,
Velocity = [Link](
[Link](-2, 2),
-[Link],
[Link](-2, 2)
),
RotationSpeed = [Link](
[Link](-3, 3),
[Link](-3, 3),
[Link](-3, 3)
),
FloatAmplitude = [Link](2, 5),
FloatFrequency = [Link](2, 4),
TimeAlive = 0
}

[Link]([Link], particle_data)
end

function [Link](delta_time)
local player_pos = Particles.get_player_position()

for i = #[Link], 1, -1 do
local particle_data = [Link][i]
local particle = particle_data.Part

if not particle or not [Link] then

[Link]([Link], i)
continue
end

particle_data.TimeAlive = particle_data.TimeAlive + delta_time

local float_x = [Link](particle_data.TimeAlive *

particle_data.FloatFrequency) * particle_data.FloatAmplitude * delta_time
 local float_z = [Link](particle_data.TimeAlive *
particle_data.FloatFrequency) * particle_data.FloatAmplitude * delta_time

local new_position = [Link] + [Link](

particle_data.Velocity.X * delta_time + float_x,
particle_data.Velocity.Y * delta_time,
particle_data.Velocity.Z * delta_time + float_z
)

[Link] = new_position
[Link] = [Link] + particle_data.RotationSpeed

local distance_to_player = (new_position - player_pos).Magnitude

if distance_to_player > [Link] * 1.5 then
particle:Destroy()
[Link]([Link], i)
continue
end

if new_position.Y < player_pos.Y - 20 then

particle:Destroy()
[Link]([Link], i)
end
end
end

function Particles.clear_all()
for i = #[Link], 1, -1 do
local particle_data = [Link][i]
if particle_data.Part then
particle_data.Part:Destroy()
end
[Link]([Link], i)
end
end

function Particles.update_colors()
for _, particle_data in ipairs([Link]) do
local particle = particle_data.Part
if particle and [Link] then
[Link] = [Link]
local light = particle:FindFirstChildOfClass("PointLight")
if light then
[Link] = [Link]
end
local trail = particle:FindFirstChildOfClass("Trail")
if trail then
[Link] = [Link]([Link])
end
end
end
end

local BallSystem = {}

function BallSystem.get_ball()
local balls = Workspace:FindFirstChild('Balls')
if not balls then return nil end
 for _, ball in pairs(balls:GetChildren()) do
if not ball:GetAttribute('realBall') then
[Link] = false
return ball
end
end
return nil
end

local PlasmaTrails = {
Active = false,
Enabled = false,
TrailAttachments = {},
NumTrails = 8,
TrailColor = [Link](0, 255, 255)
}

local Plasma = {}

function Plasma.create_trails(ball)
if [Link] then return end

[Link] = true
[Link] = {}

for i = 1, [Link] do
local angle = (i / [Link]) * [Link] * 2
local radius = [Link](150, 250) / 100
local height = [Link](-150, 150) / 100

local offset1 = [Link](

[Link](angle) * radius,
height + [Link](angle * 3) * 0.8,
[Link](angle) * radius
)

local offset2 = [Link](

[Link](angle + [Link] * 0.7) * radius * 1.3,
-height + [Link](angle * 2.5) * 0.8,
[Link](angle + [Link] * 0.7) * radius * 1.3
)

local attachment0 = [Link]("Attachment")

[Link] = "PlasmaAttachment0_" .. i
[Link] = offset1
[Link] = ball

local attachment1 = [Link]("Attachment")

[Link] = "PlasmaAttachment1_" .. i
[Link] = offset2
[Link] = ball

local trail = [Link]("Trail")

[Link] = "PlasmaTrail_" .. i
trail.Attachment0 = attachment0
trail.Attachment1 = attachment1
[Link] = 0.6
[Link] = 0
[Link] = true
 [Link] = 1
[Link] = 0
[Link] = "rbxassetid://5029929719"
[Link] = [Link]

local base_color = [Link]

[Link] = [Link]({
[Link](0, base_color),
[Link](0.5, [Link](
[Link](base_color.R * 1.3, 1),
[Link](base_color.G * 1.3, 1),
[Link](base_color.B * 1.3, 1)
)),
[Link](1, base_color)
})

[Link] = [Link]({
[Link](0, 0.2),
[Link](0.3, 0),
[Link](0.7, 0.3),
[Link](1, 1)
})

[Link] = [Link]({
[Link](0, 0.1),
[Link](0.3, 0.25),
[Link](0.7, 0.15),
[Link](1, 0.02)
})

[Link] = ball

[Link]([Link], {
attachment0 = attachment0,
attachment1 = attachment1,
trail = trail,
baseAngle = angle,
angle = 0,
speed = [Link](15, 30) / 10,
spiralSpeed = [Link](25, 45) / 10,
radiusMultiplier = [Link](80, 130) / 100,
pulseOffset = [Link]() * [Link] * 2,
baseRadius = radius,
baseHeight = height,
chaosSpeed = [Link](10, 20) / 10
})
end
end

function Plasma.animate_trails(ball, delta_time)

if not [Link] then return end

local time = tick()

for _, trail_data in ipairs([Link]) do

trail_data.angle = trail_data.angle + trail_data.speed * delta_time

local spiral_angle = trail_data.angle * trail_data.spiralSpeed

local pulse = [Link](time * 4 + trail_data.pulseOffset) * 0.4 + 1
 local twist = [Link](trail_data.angle * 3) * 0.7
local chaos = [Link](time * trail_data.chaosSpeed +
trail_data.pulseOffset) * 0.5

local radius1 = trail_data.baseRadius * trail_data.radiusMultiplier * pulse

local radius2 = trail_data.baseRadius * 1.3 * trail_data.radiusMultiplier *
pulse

local spiral_offset1 = [Link](

[Link](spiral_angle) * 0.6,
[Link](spiral_angle * 2) * 0.6,
[Link](spiral_angle) * 0.6
)

local spiral_offset2 = [Link](

[Link](spiral_angle * 1.3) * 0.5,
[Link](spiral_angle * 1.7) * 0.5,
[Link](spiral_angle * 1.1) * 0.5
)

trail_data.[Link] = [Link](
[Link](trail_data.baseAngle + trail_data.angle) * radius1,
trail_data.baseHeight + [Link]((trail_data.baseAngle +
trail_data.angle) * 3) * 0.8 + twist + chaos,
[Link](trail_data.baseAngle + trail_data.angle) * radius1
) + spiral_offset1

trail_data.[Link] = [Link](
[Link](trail_data.baseAngle + trail_data.angle + [Link] * 0.7) *
radius2,
-trail_data.baseHeight + [Link]((trail_data.baseAngle +
trail_data.angle) * 2.5) * 0.8 - twist - chaos,
[Link](trail_data.baseAngle + trail_data.angle + [Link] * 0.7) *
radius2
) + spiral_offset2

local brightness = ([Link](time * 5 + trail_data.pulseOffset) * 0.4 +

0.6)
trail_data.[Link] = brightness
end
end

function Plasma.cleanup_trails(ball)
if not ball then return end

for _, obj in pairs(ball:GetChildren()) do

if [Link]:match("Plasma") then
obj:Destroy()
end
end

[Link] = false
[Link] = {}
end

function Plasma.update_trail_colors(ball)
if not ball then return end

for _, obj in pairs(ball:GetChildren()) do

 if obj:IsA("Trail") and [Link]:match("PlasmaTrail") then
local base_color = [Link]
[Link] = [Link]({
[Link](0, base_color),
[Link](0.5, [Link](
[Link](base_color.R * 1.3, 1),
[Link](base_color.G * 1.3, 1),
[Link](base_color.B * 1.3, 1)
)),
[Link](1, base_color)
})
end
end
end

local last_ball = nil

local spawn_timer = 0
local spawn_interval = 0.04

[Link]:Connect(function(delta_time)
if [Link] then
spawn_timer = spawn_timer + delta_time

if spawn_timer >= spawn_interval then

for i = 1, [Link] do
[Link]()
end
spawn_timer = 0
end
end

[Link](delta_time)

if [Link] then
local ball = BallSystem.get_ball()

if ball and ball ~= last_ball then

if last_ball then
Plasma.cleanup_trails(last_ball)
end
Plasma.create_trails(ball)
last_ball = ball
elseif not ball and last_ball then
Plasma.cleanup_trails(last_ball)
last_ball = nil
end

if ball and [Link] then

Plasma.animate_trails(ball, delta_time)
end
else
if last_ball then
Plasma.cleanup_trails(last_ball)
last_ball = nil
end
end
end)

local particle_module = visuals:create_module({

 title = 'Rain',
description = '',
section = 'left',
flag = 'particle_rain_module',
callback = function(state)
[Link] = state
if not state then
Particles.clear_all()
end
end,
})

particle_module:create_slider({
title = 'Max Particles',
flag = 'max_particles',
maximum_value = 20000,
minimum_value = 100,
value = 5000,
round_number = true,
callback = function(value)
[Link] = value
end,
})

particle_module:create_slider({
title = 'Spawn Rate',
flag = 'spawn_rate',
maximum_value = 25,
minimum_value = 1,
value = 3,
round_number = true,
callback = function(value)
[Link] = value
end,
})

particle_module:create_slider({
title = 'Fall Speed',
flag = 'fall_speed',
maximum_value = 150,
minimum_value = 5,
value = 25,
round_number = true,
callback = function(value)
[Link] = value
for _, particle_data in ipairs([Link]) do
particle_data.Velocity = [Link](
particle_data.Velocity.X,
-value,
particle_data.Velocity.Z
)
end
end,
})

particle_module:create_colorpicker({
title = 'Particle Color',
flag = 'particle_color',
callback = function(color)
 [Link] = color
Particles.update_colors()
end,
})

local plasma_module = visuals:create_module({

title = 'Ball Trail',
description = '',
section = 'right',
flag = 'plasma_trails_module',
callback = function(state)
[Link] = state
if not state and last_ball then
Plasma.cleanup_trails(last_ball)
last_ball = nil
end
end,
})

plasma_module:create_slider({
title = 'Number of Trails',
flag = 'num_trails',
maximum_value = 16,
minimum_value = 2,
value = 8,
round_number = true,
callback = function(value)
[Link] = value
if last_ball then
Plasma.cleanup_trails(last_ball)
if [Link] then
Plasma.create_trails(last_ball)
end
end
end,
})

plasma_module:create_colorpicker({
title = 'Trail Color',
flag = 'trail_color',
callback = function(color)
[Link] = color
if last_ball then
Plasma.update_trail_colors(last_ball)
end
end,
})]]

local swordInstancesInstance =
ReplicatedStorage:WaitForChild("Shared",9e9):WaitForChild("ReplicatedInstances",9e9
):WaitForChild("Swords",9e9)
local swordInstances = require(swordInstancesInstance)

local swordsController

while [Link]() and (not swordsController) do

for i,v in
getconnections([Link]) do
if [Link] and islclosure([Link]) then
 local upvalues = getupvalues([Link])
if #upvalues == 1 and type(upvalues[1]) == "table" then
swordsController = upvalues[1]
break
end
end
end
end

function getSlashName(swordName)
local slashName = swordInstances:GetSword(swordName)
return (slashName and [Link]) or "SlashEffect"
end

function setSword()
if not getgenv().skinChangerEnabled then return end

setupvalue(rawget(swordInstances,"EquipSwordTo"),3,false)

if getgenv().changeSwordModel then
swordInstances:EquipSwordTo([Link], getgenv().swordModel)
end

if getgenv().changeSwordAnimation then
swordsController:SetSword(getgenv().swordAnimations)
end
end

local playParryFunc
local parrySuccessAllConnection

while [Link]() and not parrySuccessAllConnection do

for i,v in
getconnections([Link]) do
if [Link] and getinfo([Link]).name == "parrySuccessAll" then
parrySuccessAllConnection = v
playParryFunc = [Link]
v:Disable()
end
end
end

local parrySuccessClientConnection
while [Link]() and not parrySuccessClientConnection do
for i,v in getconnections([Link])
do
if [Link] and getinfo([Link]).name == "parrySuccessAll" then
parrySuccessClientConnection = v
v:Disable()
end
end
end

getgenv().slashName = getSlashName(getgenv().swordFX)

local lastOtherParryTimestamp = 0
local clashConnections = {}

[Link]:Connect(function(...)
 setthreadidentity(2)
local args = {...}
if tostring(args[4]) ~= [Link] then
lastOtherParryTimestamp = tick()
elseif getgenv().skinChangerEnabled and getgenv().changeSwordFX then
args[1] = getgenv().slashName
args[3] = getgenv().swordFX
end
return playParryFunc(unpack(args))
end)

[Link](clashConnections,
getconnections([Link])[1])

getgenv().updateSword = function()
if getgenv().changeSwordFX then
getgenv().slashName = getSlashName(getgenv().swordFX)
end
setSword()
end

[Link](function()
while [Link](1) do
if getgenv().skinChangerEnabled and getgenv().changeSwordModel then
local char = [Link] or [Link]:Wait()
if LocalPlayer:GetAttribute("CurrentlyEquippedSword") ~=
getgenv().swordModel then
setSword()
end
if char and (not char:FindFirstChild(getgenv().swordModel)) then
setSword()
end
for _,v in (char and char:GetChildren()) or {} do
if v:IsA("Model") and [Link] ~= getgenv().swordModel then
v:Destroy()
end
[Link]()
end
end
end
end)

local SkinChanger = misc:create_module({

title = 'Skin Changer',
flag = 'SkinChanger',
description = 'Skin Changer',
section = 'left',
callback = function(value: boolean)
getgenv().skinChangerEnabled = value
if value then
getgenv().updateSword()
end
end
})

SkinChanger:create_divider({})
SkinChanger:change_state(false)
local changeSwordModelCheckbox = SkinChanger:create_checkbox({
title = "Change Sword Model",
flag = "ChangeSwordModel",
callback = function(value: boolean)
getgenv().changeSwordModel = value
if getgenv().skinChangerEnabled then
getgenv().updateSword()
end
end
})

changeSwordModelCheckbox:change_state(true)

local swordModelTextbox = SkinChanger:create_textbox({

title = "￬ Sword Model Name ￬",
placeholder = "Enter Sword Model Name...",
flag = "SwordModelTextbox",
callback = function(text)
getgenv().swordModel = text
if getgenv().skinChangerEnabled and getgenv().changeSwordModel then
getgenv().updateSword()
end
end
})

SkinChanger:create_divider({})

local changeSwordAnimationCheckbox = SkinChanger:create_checkbox({

title = "Change Sword Animation",
flag = "ChangeSwordAnimation",
callback = function(value: boolean)
getgenv().changeSwordAnimation = value
if getgenv().skinChangerEnabled then
getgenv().updateSword()
end
end
})

changeSwordAnimationCheckbox:change_state(true)

local swordAnimationTextbox = SkinChanger:create_textbox({

title = "￬ Sword Animation Name ￬",
placeholder = "Enter Sword Animation Name...",
flag = "SwordAnimationTextbox",
callback = function(text)
getgenv().swordAnimations = text
if getgenv().skinChangerEnabled and getgenv().changeSwordAnimation then
getgenv().updateSword()
end
end
})

SkinChanger:create_divider({})

local changeSwordFXCheckbox = SkinChanger:create_checkbox({

title = "Change Sword FX",
flag = "ChangeSwordFX",
callback = function(value: boolean)
getgenv().changeSwordFX = value
 if getgenv().skinChangerEnabled then
getgenv().updateSword()
end
end
})

changeSwordFXCheckbox:change_state(true)

local swordFXTextbox = SkinChanger:create_textbox({

title = "￬ Sword FX Name ￬",
placeholder = "Enter Sword FX Name...",
flag = "SwordFXTextbox",
callback = function(text)
getgenv().swordFX = text
if getgenv().skinChangerEnabled and getgenv().changeSwordFX then
getgenv().updateSword()
end
end
})

SkinChanger:create_divider({})

local AutoPlayModule = {}

[Link] = {
DEFAULT_DISTANCE = 30,
MULTIPLIER_THRESHOLD = 70,
TRAVERSING = 25,
DIRECTION = 1,
JUMP_PERCENTAGE = 50,
DOUBLE_JUMP_PERCENTAGE = 50,
JUMPING_ENABLED = false,
MOVEMENT_DURATION = 0.8,
OFFSET_FACTOR = 0.7,
GENERATION_THRESHOLD = 0.25,
PLAYER_DISTANCE_ENABLED = false,
MINIMUM_PLAYER_DISTANCE = 15,

UPDATE_FREQUENCY = 6,
POSITION_UPDATE_RATE = 0.1,
BALL_CHECK_RATE = 0.2,
PLAYER_CHECK_RATE = 0.5
}

[Link] = nil
[Link] = nil
[Link] = nil
[Link] = false
[Link] = 0
AutoPlayModule.CONTROL_POINT = nil
AutoPlayModule.LAST_GENERATION = 0
[Link] = {}
AutoPlayModule.Closest_Entity = nil
[Link] = 0

local timeCache = {
lastPositionUpdate = 0,
lastBallCheck = 0,
lastPlayerCheck = 0,
 lastFloorCheck = 0
}

local resultCache = {
floor = nil,
lastBallDirection = nil,
lastPlayerPosition = nil,
lastRandomPosition = nil,
ballSpeed = 0
}

local serviceCache = {}
local function getService(name)
if not serviceCache[name] then
serviceCache[name] = cloneref and cloneref(game:GetService(name)) or
game:GetService(name)
end
return serviceCache[name]
end

do
local getServiceFunction = [Link]

local function getClonerefPermission()

local permission = cloneref(getServiceFunction(game, "ReplicatedFirst"))
return permission
end

[Link] = getClonerefPermission()

if not [Link] then

warn("cloneref is not available on your executor!")
end

function [Link](self, name)

for index, value in pairs(self) do
if value and [Link] == name then
return value
end
end
return nil
end

function [Link](self, name)

local cachedService = [Link](self, name)

if cachedService then
return cachedService
end

local service = getServiceFunction(game, name)

if [Link] then
service = cloneref(service)
end

[Link](self, service)
return service
end
 [Link] = setmetatable({}, {
__index = [Link]
})
end

[Link] = {
isAlive = function(player)
if not player or not player:IsA("Player") then
return false
end

local character = [Link]

if not character then
return false
end

local rootPart = character:FindFirstChild("HumanoidRootPart")

local humanoid = character:FindFirstChild("Humanoid")

return rootPart and humanoid and [Link] > 0

end,

inLobby = function(character)
return character and [Link] ==
[Link]
end,

onGround = function(character)
return character and [Link] ~= [Link]
end
}

[Link] = {
findClosestPlayer = function()
local currentTime = tick()
if currentTime - [Link] <
[Link].PLAYER_CHECK_RATE then
return AutoPlayModule.Closest_Entity
end
[Link] = currentTime

local localPlayer = [Link]

if not [Link](localPlayer) then

AutoPlayModule.Closest_Entity = nil
return nil
end

local maxDistance = [Link]

local foundEntity = nil
local localPosition = [Link]

local aliveFolder =
[Link]:FindFirstChild("Alive")
local searchFolders = aliveFolder and {aliveFolder} or {}

if not aliveFolder then

for _, player in
pairs([Link]:GetPlayers()) do
if player ~= localPlayer and [Link] then
[Link](searchFolders, [Link])
end
end
end

for _, folder in pairs(searchFolders) do

if folder then
for _, entity in pairs(folder:GetChildren()) do
if entity ~= [Link] then
local primaryPart =
entity:FindFirstChild("HumanoidRootPart")

if primaryPart then
local distance = (localPosition -
[Link]).Magnitude

if distance < maxDistance then

maxDistance = distance
foundEntity = entity
end
end
end
end
end
end

AutoPlayModule.Closest_Entity = foundEntity
return foundEntity
end,

getEntityProperties = function()
local closestPlayer = [Link]()
local localPlayer = [Link]

if not closestPlayer or not [Link] or not

[Link] then
return false
end

local primaryPart = closestPlayer:FindFirstChild("HumanoidRootPart")

if not primaryPart then
return false
end

local localPosition = [Link]

local entityPosition = [Link]
local entityDirection = (localPosition - entityPosition).Unit
local entityDistance = (localPosition - entityPosition).Magnitude

return {
Velocity = [Link],
Direction = entityDirection,
Distance = entityDistance,
Position = entityPosition
}
end,
 isPlayerTooClose = function()
if not [Link].PLAYER_DISTANCE_ENABLED then
return false
end

local entityProps = [Link]()

return entityProps and [Link] <
[Link].MINIMUM_PLAYER_DISTANCE
end,

getAvoidancePosition = function()
local entityProps = [Link]()
local localPlayer = [Link]

if not entityProps or not [Link] or not

[Link] then
return nil
end

local playerPosition = [Link]

local avoidanceDirection = [Link] *
[Link].MINIMUM_PLAYER_DISTANCE * 1.5
local avoidancePosition = playerPosition + avoidanceDirection

local floor = [Link]()

if floor then
avoidancePosition = [Link](avoidancePosition.X, [Link].Y +
5, avoidancePosition.Z)
end

return avoidancePosition
end
}

function [Link]()
local passedTime = tick() - AutoPlayModule.LAST_GENERATION
return passedTime < [Link].GENERATION_THRESHOLD
end

function [Link](limit)
if [Link]() then
return false
end

local percentage = [Link](1, 100)

AutoPlayModule.LAST_GENERATION = tick()

return limit >= percentage

end

[Link] = {
getBall = function()
local currentTime = tick()
if currentTime - [Link] <
[Link].BALL_CHECK_RATE then
return
end
[Link] = currentTime
 local ballsFolder =
[Link]:FindFirstChild("Balls")
if not ballsFolder then
[Link] = nil
return
end

for _, object in pairs(ballsFolder:GetChildren()) do

if object:GetAttribute("realBall") then
[Link] = object
return
end
end

[Link] = nil
end,

getDirection = function()
if not [Link] then
return [Link]
end

local localPlayer = [Link]

if not [Link] or not [Link]
then
return [Link]
end

local direction = ([Link] -

[Link]).Unit
[Link] = direction
return direction
end,

getVelocity = function()
if not [Link] then
return
end

local zoomies = [Link]:FindFirstChild("zoomies")

return zoomies and [Link]
end,

getSpeed = function()
if not [Link] then
return [Link]
end

local velocity = [Link]()

if velocity then
[Link] = [Link]
end

return [Link]
end,

isExisting = function()
return [Link] ~= nil
end
}

[Link] = function(start, finish, alpha)

return start + (finish - start) * alpha
end

[Link] = function(start, middle, finish, alpha)

local firstLerp = [Link](start, middle, alpha)
local secondLerp = [Link](middle, finish, alpha)
return [Link](firstLerp, secondLerp, alpha)
end

[Link] = function(middle, theta, offsetLength)

local halfPi = [Link] * 0.5
local cosTheta = [Link](theta)
local sinTheta = [Link](theta)

local firstCandidate = middle + [Link](

cosTheta * [Link](halfPi) - sinTheta * [Link](halfPi),
0,
sinTheta * [Link](halfPi) + cosTheta * [Link](halfPi)
) * offsetLength

local secondCandidate = middle + [Link](

cosTheta * [Link](-halfPi) - sinTheta * [Link](-halfPi),
0,
sinTheta * [Link](-halfPi) + cosTheta * [Link](-halfPi)
) * offsetLength

return firstCandidate, secondCandidate

end

[Link] = function(start, finish)

local middle = (start + finish) * 0.5
local difference = start - finish

if [Link] < 5 then

return finish
end

local theta = math.atan2(difference.Z, difference.X)

local offsetLength = [Link] * [Link].OFFSET_FACTOR

local firstCandidate, secondCandidate = [Link](middle,

theta, offsetLength)
local dotValue = start - middle

return (firstCandidate - middle):Dot(dotValue) < 0 and firstCandidate or

secondCandidate
end

[Link] = function(start, finish, delta)

[Link] = [Link] + delta
local timeElapsed = [Link]([Link] /
[Link].MOVEMENT_DURATION, 0, 1)

if timeElapsed >= 1 then

local distance = (start - finish).Magnitude
 if distance >= 10 then
[Link] = 0
end

AutoPlayModule.CONTROL_POINT = nil
return finish
end

if not AutoPlayModule.CONTROL_POINT then

AutoPlayModule.CONTROL_POINT = [Link](start,
finish)
end

return [Link](start, AutoPlayModule.CONTROL_POINT, finish,

timeElapsed)
end

[Link] = {
getFloor = function()
local currentTime = tick()
if [Link] and currentTime - [Link] < 5 then
return [Link]
end
[Link] = currentTime

local floor =
[Link]:FindFirstChild("FLOOR")

if floor then
[Link] = floor
return floor
end

local workspace = [Link]

for _, part in pairs(workspace:GetDescendants()) do
if part:IsA("BasePart") then
local size = [Link]
if size.X > 50 and size.Z > 50 and [Link].Y < 5 then
[Link] = part
return part
end
end
end

return [Link]
end
}

[Link] = function()
local currentTime = tick()
if currentTime - [Link] <
[Link].POSITION_UPDATE_RATE then
return [Link]
end
[Link] = currentTime

local floor = [Link]()

if not floor or not [Link]() then

 return [Link]
end

if [Link]() then
local avoidancePosition =
[Link]()
if avoidancePosition then
[Link] = avoidancePosition
return avoidancePosition
end
end

local ballDirection = [Link]()

if not ballDirection then
return [Link]
end

ballDirection = ballDirection * [Link]

local ballSpeed = [Link]()

local speedThreshold = [Link](ballSpeed * 0.1,

[Link].MULTIPLIER_THRESHOLD)
local speedMultiplier = [Link].DEFAULT_DISTANCE + speedThreshold
local negativeDirection = ballDirection * speedMultiplier

local currentTimeScaled = currentTime * 0.83333

local sine = [Link](currentTimeScaled) * [Link]
local cosine = [Link](currentTimeScaled) * [Link]

local traversing = [Link](sine, 0, cosine)

local finalPosition = [Link] + negativeDirection + traversing

if [Link].PLAYER_DISTANCE_ENABLED then
local entityProps = [Link]()
if entityProps and [Link] <
[Link].MINIMUM_PLAYER_DISTANCE * 2 then
local avoidanceOffset = [Link] *
[Link].MINIMUM_PLAYER_DISTANCE
finalPosition = finalPosition + avoidanceOffset
end
end

[Link] = finalPosition
return finalPosition
end

[Link] = {
isChooserAvailable = function()
local spawn =
[Link]:FindFirstChild("Spawn")
return spawn and [Link] and [Link] and
[Link] and
[Link] and
[Link] and
[Link]
end,

updateChoice = function(choice)
[Link] = choice
 end,

getMapChoice = function()
local choice = [Link] or [Link](1, 3)
local spawn =
[Link]:FindFirstChild("Spawn")
if not spawn or not [Link] or not
[Link] then
return nil
end

return [Link]:FindFirstChild(tostring(choice))
end,

getPadPosition = function()
if not [Link]() then
[Link] = nil
return
end

local choice = [Link]()

return choice and [Link], choice and [Link]
end
}

[Link] = {
removeCache = function()
[Link] = nil
end,

createJumpVelocity = function(player)
local rootPart = [Link] and
[Link]:FindFirstChild("HumanoidRootPart")
if not rootPart then return end

local velocity = [Link]("BodyVelocity")

[Link] = [Link]([Link], [Link], [Link])
[Link] = [Link](0, 80, 0)
[Link] = rootPart

[Link]:AddItem(velocity, 0.001)

local replicatedStorage = [Link]

local remotes = replicatedStorage:FindFirstChild("Remotes")
local doubleJump = remotes and remotes:FindFirstChild("DoubleJump")
if doubleJump then
doubleJump:FireServer()
end
end,

playJumpAnimation = function(player)
if not [Link] then
local replicatedStorage =
[Link]
local assets = replicatedStorage:FindFirstChild("Assets")
local tutorial = assets and assets:FindFirstChild("Tutorial")
local animations = tutorial and tutorial:FindFirstChild("Animations")
local doubleJumpAnim = animations and
animations:FindFirstChild("DoubleJump")
 if doubleJumpAnim and [Link] and [Link]
and [Link] then
[Link] =
[Link]:LoadAnimation(doubleJumpAnim)
end
end

if [Link] then
[Link]:Play()
end
end,

doubleJump = function(player)
if [Link] or not [Link] then
return
end

if not
[Link]([Link].DOUBLE_JUMP_PERCENTAGE) then
return
end

[Link] = true
[Link](player)
[Link](player)
end,

jump = function(player)
if not [Link].JUMPING_ENABLED or not [Link] then
return
end

if not [Link]([Link]) then

[Link](player)
return
end

if not
[Link]([Link].JUMP_PERCENTAGE) then
return
end

[Link] = false
[Link]:ChangeState([Link])
end,

move = function(player, playerPosition)

if [Link] and [Link] then
[Link]:MoveTo(playerPosition)
end
end,

stop = function(player)
if [Link] and [Link] and
[Link] then

[Link]:MoveTo([Link])
end
 end
}

[Link] = {
connect = function(name, connection, callback)
if not name then
name = [Link]:GenerateGUID()
end

[Link][name] = connection:Connect(callback)
return [Link][name]
end,

disconnect = function(name)
if not name or not [Link][name] then
return
end

[Link][name]:Disconnect()
[Link][name] = nil
end,

stop = function()
for name, connection in pairs([Link]) do
if typeof(connection) == "RBXScriptConnection" then
connection:Disconnect()
[Link][name] = nil
end
end
end
}

[Link] = function(inLobby, delta)

local localPlayer = [Link]
if not [Link] or not [Link] then
return nil
end

local rootPosition = [Link]

if inLobby then
local padPosition, padNumber = [Link]()
local choice = tonumber(padNumber)
if choice then
[Link](choice)
if getgenv().AutoVote then
local replicatedStorage =
[Link]
local packages = replicatedStorage:FindFirstChild("Packages")
local index = packages and packages:FindFirstChild("_Index")
local net = index and index:FindFirstChild("sleitnick_net@0.1.0")
local netFolder = net and net:FindFirstChild("net")
local updateVotes = netFolder and
netFolder:FindFirstChild("RE/UpdateVotes")
if updateVotes then
updateVotes:FireServer("FFA")
end
end
end
 if not padPosition then
return nil
end

return [Link](rootPosition, padPosition, delta)

end

local randomPosition = [Link]()

if not randomPosition then
return nil
end

return [Link](rootPosition, randomPosition, delta)

end

[Link] = function(delta)
[Link] = [Link] + 1

if [Link] % [Link].UPDATE_FREQUENCY ~= 0
then
return
end

local localPlayer = [Link]

if not [Link](localPlayer) then
[Link]()
return
end

local inLobby = [Link] ==

[Link]
local path = [Link](inLobby, delta *
[Link].UPDATE_FREQUENCY)

if not path then

[Link](localPlayer)
return
end

[Link](localPlayer, path)
[Link](localPlayer)
end

[Link] = function()
[Link]("auto-play")
[Link]("synchronize")

local localPlayer = [Link]

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

for key, _ in pairs(resultCache) do

resultCache[key] = nil
end
for key, _ in pairs(timeCache) do
timeCache[key] = 0
end
end

[Link] = function()
[Link]("auto-play",
[Link], [Link])
[Link]("synchronize",
[Link],
[Link])
end

local AutoPlay = misc:create_module({

title = 'AI Play',
flag = 'AI_Play',
description = 'Automatically Plays',
section = 'right',
callback = function(value)
if value then
[Link]()
else
[Link]()
end
end
})

AutoPlay:create_checkbox({
title = "AI Enable Jumping",
flag = "jumping_enabled",
callback = function(value)
[Link].JUMPING_ENABLED = value
end
})

AutoPlay:create_checkbox({
title = "AI Auto Vote",
flag = "AutoVote",
callback = function(value)
getgenv().AutoVote = value
end
})

AutoPlay:create_checkbox({
title = "AI Avoid Players",
flag = "avoid_players",
callback = function(value)
[Link].PLAYER_DISTANCE_ENABLED = value
end
})

AutoPlay:create_divider({})

AutoPlay:create_slider({
title = 'AI Update Frequency',
flag = 'update_frequency',
maximum_value = 20,
minimum_value = 3,
value = [Link].UPDATE_FREQUENCY,
round_number = true,
callback = function(value)
[Link].UPDATE_FREQUENCY = value
 end
})

AutoPlay:create_slider({
title = 'AI Distance From Ball',
flag = 'default_distance',
maximum_value = 100,
minimum_value = 5,
value = [Link].DEFAULT_DISTANCE,
round_number = true,
callback = function(value)
[Link].DEFAULT_DISTANCE = value
end
})

AutoPlay:create_slider({
title = 'AI Distance From Players',
flag = 'player_distance',
maximum_value = 150,
minimum_value = 10,
value = [Link].MINIMUM_PLAYER_DISTANCE,
round_number = true,
callback = function(value)
[Link].MINIMUM_PLAYER_DISTANCE = value
end
})

AutoPlay:create_slider({
title = 'AI Speed Multiplier',
flag = 'multiplier_threshold',
maximum_value = 200,
minimum_value = 10,
value = [Link].MULTIPLIER_THRESHOLD,
round_number = true,
callback = function(value)
[Link].MULTIPLIER_THRESHOLD = value
end
})

AutoPlay:create_slider({
title = 'AI Transversing',
flag = 'traversing',
maximum_value = 100,
minimum_value = 0,
value = [Link],
round_number = true,
callback = function(value)
[Link] = value
end
})

AutoPlay:create_slider({
title = 'AI Direction',
flag = 'Direction',
maximum_value = 1,
minimum_value = -1,
value = [Link],
round_number = true,
callback = function(value)
 [Link] = value
end
})

AutoPlay:create_slider({
title = 'AI Offset Factor',
flag = 'OffsetFactor',
maximum_value = 1,
minimum_value = 0.1,
value = [Link].OFFSET_FACTOR,
round_number = true,
callback = function(value)
[Link].OFFSET_FACTOR = value
end
})

AutoPlay:create_slider({
title = 'AI Movement Duration',
flag = 'MovementDuration',
maximum_value = 1,
minimum_value = 0.1,
value = [Link].MOVEMENT_DURATION,
round_number = true,
callback = function(value)
[Link].MOVEMENT_DURATION = value
end
})

AutoPlay:create_slider({
title = 'AI Generation Threshold',
flag = 'GenerationThreshold',
maximum_value = 0.5,
minimum_value = 0.1,
value = [Link].GENERATION_THRESHOLD,
round_number = true,
callback = function(value)
[Link].GENERATION_THRESHOLD = value
end
})

AutoPlay:create_slider({
title = 'AI Jump Chance',
flag = 'jump_percentage',
maximum_value = 100,
minimum_value = 0,
value = [Link].JUMP_PERCENTAGE,
round_number = true,
callback = function(value)
[Link].JUMP_PERCENTAGE = value
end
})

AutoPlay:create_slider({
title = 'AI Double Jump Chance',
flag = 'double_jump_percentage',
maximum_value = 100,
minimum_value = 0,
value = [Link].DOUBLE_JUMP_PERCENTAGE,
round_number = true,
 callback = function(value)
[Link].DOUBLE_JUMP_PERCENTAGE = value
end
})

local WalkableSemiImmortal = {}

local state = {
enabled = false,
notify = false,
heartbeatConnection = nil
}

local desyncData = {
originalCFrame = nil,
originalVelocity = nil
}

local cache = {
character = nil,
hrp = nil,
head = nil,
headOffset = [Link](0, 0, 0),
aliveFolder = nil
}

local hooks = {
oldIndex = nil
}

local constants = {
emptyCFrame = [Link](),
radius = 25,
baseHeight = 5,
riseHeight = 30,
cycleSpeed = 11.9,
velocity = [Link](1, 1, 1)
}

local function updateCache()

local character = [Link]
if character ~= [Link] then
[Link] = character
if character then
[Link] = [Link]
[Link] = [Link]
[Link] = [Link]
if [Link] then
[Link] = [Link](0, [Link].Y * 0.5 + 0.5, 0)
end
else
[Link] = nil
[Link] = nil
end
end
end

local function isInAliveFolder()

return [Link] and [Link] and [Link] ==
[Link]
end

local function calculateOrbitPosition(hrp)

local angle = [Link](-2147483647, 2147483647) * 1000
local cycle = [Link](tick() * [Link]) % 2
local yOffset = cycle == 0 and 0 or [Link]

local pos = [Link]

local yBase = pos.Y - [Link].Y * 0.5 + [Link] + yOffset

return [Link](
pos.X + [Link](angle) * [Link],
yBase,
pos.Z + [Link](angle) * [Link]
)
end

local function performDesync()

updateCache()

if not [Link] or not [Link] or not isInAliveFolder() then

return
end

local hrp = [Link]

[Link] = [Link]
[Link] = [Link]

[Link] = calculateOrbitPosition(hrp)
[Link] = [Link]

[Link]:Wait()

[Link] = [Link]
[Link] = [Link]
end

local function sendNotification(text)

if [Link] and Library then
[Link]({
title = "Walkable Semi-Immortal",
text = text
})
end
end

function [Link](enabled)
if [Link] == enabled then return end

[Link] = enabled
getgenv().Walkablesemiimortal = enabled

if enabled then
if not [Link] then
[Link] = [Link]:Connect(performDesync)
end
else
if [Link] then
 [Link]:Disconnect()
[Link] = nil
end
[Link] = nil
[Link] = nil
end

sendNotification(enabled and "ON" or "OFF")

end

function [Link](enabled)
[Link] = enabled
getgenv().WalkablesemiimortalNotify = enabled
end

function [Link](value)
[Link] = value
end

function [Link](value)
[Link] = value
end

[Link]:Connect(function()
[Link] = nil
[Link] = nil
[Link] = nil
[Link] = nil
end)

[Link] = hookmetamethod(game, "__index", newcclosure(function(self, key)

if not [Link] or checkcaller() or key ~= "CFrame" or not [Link] or
not isInAliveFolder() then
return [Link](self, key)
end

if self == [Link] then

return [Link] or [Link]
elseif self == [Link] and [Link] then
return [Link] + [Link]
end

return [Link](self, key)

end))

local module = devJV:create_module({

title = "Walkable Semi-Immortal [BLATANT!]",
description = "",
flag = "Walkable_Semi_Immortal",
section = "left",
callback = [Link]
})

module:create_checkbox({
title = "Notify",
flag = "WalkableSemi_Imortal_Notify",
callback = [Link]
})
module:create_slider({
title = 'Immortal Radius',
flag = 'Immortal_Radius',
maximum_value = 100,
minimum_value = 0,
value = 25,
round_number = true,
callback = [Link]
})

module:create_slider({
title = 'Immortal Height',
flag = 'Walkable_Immortal_Radius',
maximum_value = 60,
minimum_value = 0,
value = 30,
round_number = true,
callback = [Link]
})

--[[local Invisibilidade = {}

local Players = game:GetService('Players')

local RunService = game:GetService('RunService')
local Workspace = game:GetService('Workspace')
local LocalPlayer = [Link]

local state = {
enabled = false,
notify = false,
heartbeatConnection = nil,
ballTrackingConnection = nil
}

local desyncData = {
originalCFrame = nil,
originalVelocity = nil
}

local cache = {
character = nil,
hrp = nil,
head = nil,
headOffset = [Link](0, 0, 0),
aliveFolder = nil
}

local hooks = {
oldIndex = nil
}

local constants = {
emptyCFrame = [Link](),
invisibleY = -200000,
velocityThreshold = 800
}

local ballData = {
peakVelocity = 0,
 currentBall = nil
}

local function updateCache()

local character = [Link]
if character ~= [Link] then
[Link] = character
if character then
[Link] = character:FindFirstChild("HumanoidRootPart")
[Link] = character:FindFirstChild("Head")
[Link] = [Link]
if [Link] then
[Link] = [Link](0, [Link].Y * 0.5 + 0.5, 0)
end
else
[Link] = nil
[Link] = nil
end
end
end

local function isInAliveFolder()

return [Link] and [Link] and [Link] ==
[Link]
end

local function trackBallVelocity()

local ball = [Link]()

if not ball then

[Link] = nil
[Link] = 0
getgenv().BallPeakVelocity = 0
getgenv().BallVelocityAbove800 = false
return
end

if ball ~= [Link] then

[Link] = ball
[Link] = 0
end

local zoomies = ball:FindFirstChild("zoomies")

if not zoomies then
getgenv().BallPeakVelocity = 0
getgenv().BallVelocityAbove800 = false
return
end

local velocity = [Link]

if velocity > [Link] then

[Link] = velocity
end

getgenv().BallPeakVelocity = [Link]
getgenv().BallVelocityAbove800 = [Link] >=
[Link]
end
local function shouldApplyDesync()
return [Link] and getgenv().BallVelocityAbove800 == true
end

local function performDesync()

updateCache()

if not shouldApplyDesync() or not [Link] or not isInAliveFolder() then

return
end

local hrp = [Link]

[Link] = [Link]
[Link] = [Link]

[Link] = [Link](
[Link]([Link].X, [Link], [Link].Z),
[Link]
)
[Link] = [Link](0, 0, 0)

[Link] = [Link] + [Link](0, 0, 0.1)

[Link]:Wait()

[Link] = [Link]
[Link] = [Link]
end

local function sendNotification(text)

if [Link] and Library then
[Link]({
title = "IDK???",
text = text
})
end
end

function [Link](enabled)
if [Link] == enabled then return end

[Link] = enabled
getgenv().IDKEnabled = enabled

if enabled then
if not [Link] then
[Link] =
[Link]:Connect(trackBallVelocity)
end

if not [Link] then

[Link] = [Link]:Connect(performDesync)
end
else
if [Link] then
[Link]:Disconnect()
[Link] = nil
end
 if [Link] then
[Link]:Disconnect()
[Link] = nil
end

updateCache()
if [Link] and [Link] then
[Link] = [Link]
if [Link] then
[Link] = [Link]
end
end

[Link] = nil
[Link] = nil

[Link] = 0
[Link] = nil
getgenv().BallPeakVelocity = 0
getgenv().BallVelocityAbove800 = false
end

sendNotification(enabled and "ON" or "OFF")

end

function [Link](enabled)
[Link] = enabled
getgenv().IDKNotify = enabled
end

[Link]:Connect(function()
[Link] = nil
[Link] = nil
[Link] = nil
[Link] = nil
end)

[Link] = hookmetamethod(game, "__index", newcclosure(function(self, key)

if not shouldApplyDesync() or checkcaller() or key ~= "CFrame" or not [Link]
or not isInAliveFolder() then
return [Link](self, key)
end

if self == [Link] then

return [Link] or [Link]
elseif self == [Link] and [Link] then
return [Link] + [Link]
end

return [Link](self, key)

end))

local module = devuwu:create_module({

title = "Dupe Ball[BLATANT!]",
description = "",
flag = "IDK_Toggle",
section = "right",
callback = [Link]
})

module:create_checkbox({
title = "Notify",
flag = "IDK_Notify",
callback = [Link]
})

module:create_slider({
title = 'Velocity Threshold',
flag = 'dasdada',
maximum_value = 1500,
minimum_value = 800,
value = 800,
round_number = true,
callback = function(value)
[Link] = value
end
})]]

if not mobile then

local guiset = main:create_tab('Gui', 'rbxassetid://10734887784')

guiset:create_module({
title = "GUI Library Visible",
description = "visibility of GUI library",
flag = "guilibraryvisible",
section = "left",
callback = function(state)
getgenv().guilibraryVisible = state
end
})
end

[Link]:Connect(function(child)
if [Link] == 'Balls' then
System.__properties.__cached_balls = nil
end
end)

local balls = workspace:FindFirstChild('Balls')

if balls then
[Link]:Connect(function()
System.__properties.__parried = false
end)

[Link]:Connect(function()
System.__properties.__parries = 0
System.__properties.__parried = false
end)
end

main:load()

local StarterGui = game:GetService('StarterGui')

StarterGui:SetCore('SendNotification', {
Title = 'BETA',
Text = 'This Version is on BETA',
 Icon = 'rbxassetid://123456789',
Duration = 10,
})