Message

--[[
**Change Logs
[+] Updated to lastest ui version
[+] Added Skeleton ESP (Will drop fps insanely, You can dm me if you want it
removed because of the fps)
[#] Fixed Time Changer Showing Flooded Values
--]]
--[[
Menu Bind set to default: Insert, Changable in first line.
Use loadstring incase I update it.
This script has been made by argyyy#1355, Which is me.
I would like to say this script been helped by some people and I really appreciate.
Everyone can use this script for playing in-game or just learning from it.
I would like to hear your opinion and suggestion, even if its bad or its good:
argyyy#1355.
I ask, don't steal/paste off the code, few months ago I used to do that and it was
a mistake it is more fun to do it yourself.
Anyways this script was made in Synapse X, It might work on other executors but
this is the most trusted one.
Enjoy Your Time!
--]]
local MenuBind = Enum.KeyCode.Insert
local uis = game:GetService("UserInputService")

local rs = game:GetService("RunService")
local ts = game:GetService("TweenService")
local plrs = game:GetService("Players")
local stats = game:GetService("Stats")
local lplr = plrs.LocalPlayer
-- / vector 2
local v2new = Vector2.new

local v2zero = Vector2.zero
-- / color3
local c3rgb, c3hsv = Color3.fromRGB, Color3.fromHSV
-- // library!!!
local library = {
drawings = {{}, {}},
preloaded_images = {},
connections = {},
flags = {},
pointers = {},
groups = {},
loaded = false,
}
-- // utility
local utility = {}
-- // utility coding
do
utility.vozoid_tween =
loadstring(game:HttpGet("https://raw.githubusercontent.com/vozoid/utility/main/
Tween.lua"))()
-- // utility:Draw is super pasted and skidded and shitcoded even i cant read
it even tho i coded it
-- // xyl pls dont ban me for this code 😭😢
-- // 24 december 2022: added groups to make my life easier
function utility:Draw(class, offset, properties, t)

t = t or false
local draw = Drawing.new(class)

local fakeDraw = {}
rawset(fakeDraw, "__OBJECT_EXIST", true)
local customProperties = {
["Parent"] = function(object)
table.insert(rawget(object, "children"), fakeDraw)
end,
["Group"] = function(name)
if library.groups[name] == nil then
library.groups[name] = {}
end
table.insert(library.groups[name], fakeDraw)
end,
["OffsetX"] = function(x)
fakeDraw.SetOffset(x, fadeDraw.GetOffset().Y)
end,
["OffsetY"] = function(Y)
fakeDraw.SetOffset(fadeDraw.GetOffset().X, y)
end
}
setmetatable(fakeDraw, {
__index = function(self, key)
if rawget(fakeDraw, "__OBJECT_EXIST") then
return draw[key]
end
end,
__newindex = function(self, key, value)
if customProperties[key] then
customProperties[key](value)
else
draw[key] = value
if key == "Position" then
for _, v in pairs(rawget(fakeDraw, "children")) do
v.Position = fakeDraw.Position + v.GetOffset()
end
end
end
end
end
})
rawset(fakeDraw, "Remove", function()
draw:Remove()
rawset(fakeDraw, "__OBJECT_EXIST", false)
end
end)
rawset(fakeDraw, "GetType", function()
return class
end)
rawset(fakeDraw, "GetOffset", function()
return offset or v2new()
end)
rawset(fakeDraw, "SetOffset", function(noffset)
offset = noffset or v2new()
if properties and properties.Parent then

fakeDraw.Position = properties.Parent.Position +
fakeDraw.GetOffset()
end
end)
rawset(fakeDraw, "__properties", properties)
rawset(fakeDraw, "children", {})
local lerpLoop
function lerp(v1, v2, ptc) -- // exists so it does work for Color3 n shit
if typeof(v1) == "number" then
return v1 + ((v2 - v1) * ptc)
end
return v1:Lerp(v2, ptc)
end
rawset(fakeDraw, "Lerp", function(to, time, removeOld)

if not rawget(fakeDraw, "__OBJECT_EXIST") then return end
--utility.vozoid_tween.new(fakeDraw, TweenInfo.new(instanceTime,
Enum.EasingStyle.Linear, Enum.EasingDirection.InOut), instanceTo):Play()
local from = {}
for i, _ in pairs(to) do
from[i] = fakeDraw[i]
end
local elapsed = 0
if lerpLoop ~= nil and removeOld then

lerpLoop:Disconnect()
lerpLoop = nil
end
local loop; loop = rs.Heartbeat:Connect(function(delta)
if elapsed == time then

for i, v in pairs(to) do
fakeDraw[i] = v
end
lerpLoop = nil
loop:Disconnect()
end
local ptc = (elapsed / time)
for i, v in pairs(to) do
fakeDraw[i] = lerp(from[i], v, ptc)
end
elapsed = math.clamp(elapsed + delta, 0, time)
end)
lerpLoop = loop
end)
if class == "Square" or class == "Circle" or class == "Line" then

fakeDraw.Thickness = 1
if class == "Square" then
fakeDraw.Filled = true
fakeDraw.Thickness = 1
end
end
if class ~= "Image" then

fakeDraw.Color = Color3.new(0, 0, 0)
end
fakeDraw.Visible = library.loaded
if properties ~= nil then
for key, value in pairs(properties) do
if customProperties[key] == nil then
fakeDraw[key] = value
else
customProperties[key](value)
end
end
if properties.Parent then
fakeDraw.Position = properties.Parent.Position +
fakeDraw.GetOffset()
end
if properties.Parent and properties.From then
fakeDraw.From = properties.Parent.Position + fakeDraw.GetOffset()
end
if properties.Parent and properties.To then
fakeDraw.To = properties.Parent.Position + fakeDraw.GetOffset()
end
end
if not library.loaded and not t then

fakeDraw.Transparency = 0
end
properties = properties or {}
if not t then
table.insert(library.drawings[1], {fakeDraw, properties["Transparency"]
or 1, class})
else
table.insert(library.drawings[2], {fakeDraw, properties["Transparency"]
or 1, class})
end
return fakeDraw
end
function utility:ScreenSize()
return workspace.CurrentCamera.ViewportSize
end
function utility:RoundVector(vector)
return v2new(math.floor(vector.X), math.floor(vector.Y))
end
function utility:MouseOverDrawing(object)
local values = {object.Position, object.Position + object.Size}
local mouseLocation = uis:GetMouseLocation()
return mouseLocation.X >= values[1].X and mouseLocation.Y >= values[1].Y
and mouseLocation.X <= values[2].X and mouseLocation.Y <= values[2].Y
end
function utility:MouseOverPosition(values)
local mouseLocation = uis:GetMouseLocation()
return mouseLocation.X >= values[1].X and mouseLocation.Y >= values[1].Y
and mouseLocation.X <= values[2].X and mouseLocation.Y <= values[2].Y
end
function utility:PreloadImage(link)
local data = library.preloaded_images[link] or game:HttpGet(link)
if library.preloaded_images[link] == nil then
library.preloaded_images[link] = data
end
return data
end
function utility:Image(object, link)

local data = library.preloaded_images[link] or game:HttpGet(link)
if library.preloaded_images[link] == nil then
library.preloaded_images[link] = data
end
object.Data = data
end
function utility:Connect(connection, func)

local con = connection:Connect(func)
table.insert(library.connections, con)
return con
end
function utility:BindToRenderStep(name, priority, func)

local fake_connection = {}
function fake_connection:Disconnect()
rs:UnbindFromRenderStep(name)
end
rs:BindToRenderStep(name, priority, func)
return fake_connection
end
function utility:Combine(t1, t2)

local t3 = {}
for i, v in pairs(t1) do
table.insert(t3, v)
end
for i, v in pairs(t2) do
table.insert(t3, v)
end
return t3
end
-- // xyl thanks for the method cause im npc
function utility:GetPlexSize(text)
return #text * 7
end
function utility:CopyTable(tbl)
local newtbl = {}
for i, v in pairs(tbl) do
newtbl[i] = v
end
return newtbl
end
-- // function i will never use?
function utility:ShiftKey(key)
if string.byte(key) >= 65 and string.byte(key) <= 122 then
return key:upper()
else
local shiftKeybinds = {["-"] = "_", ["="] = "+", ["1"] = "!", ["2"] =
"@", ["3"] = "#", ["4"] = "$", ["5"] = "%", ["6"] = "^", ["7"] = "&", ["8"] = "*",
["9"] = "(", ["0"] = ")", [";"] = ":", ["'"] = "\"", ["\\"] = "|", ["/"] = "?"}
return shiftKeybinds[key] or key
end
end
-- // totally not pasted from splix (100%)

-- // oh no im a paster
utility.short_keybind_names = {["MouseButton1"] = "MB1", ["MouseButton2"] =

"MB2", ["MouseButton3"] = "MB3", ["Insert"] = "INS", ["LeftAlt"] = "LALT",
["LeftControl"] = "LC", ["LeftShift"] = "LS", ["RightAlt"] = "RALT",
["RightControl"] = "RC", ["RightShift"] = "RS", ["CapsLock"] = "CAPS", ["Return"] =
"RET", ["Backspace"] = "BSP"}
end
function library.Window(self, info, theme)
theme = theme or {
accent = c3rgb(0, 255, 0),
dcont = c3rgb(20, 20, 20),
lcont = c3rgb(40, 40, 40),
cont = c3rgb(30, 30, 30),
outline = c3rgb(0, 0, 0),
outline2 = c3rgb(45, 45, 45)
}
local name = info.name or "worst ui library ever"

local size = typeof(info.size) == "Vector2" and info.size or v2new(500, 600)
local window = {shit = {}, kbds = {}, rna = {}, sshit = nil, theme = theme,
tabs = {}, _last = {0, 0}, start = v2zero, connections = {}, dragging = false}
local main_frame = utility:Draw("Square", nil, {

Size = size,
Color = window.theme.lcont,
Group = "lcont",
Position = utility:RoundVector(utility:ScreenSize() / 2 - v2new(250, 300))
})
window.frame = main_frame
utility:Connect(uis.InputBegan, function(input)
if main_frame.Visible and input.UserInputType ==
Enum.UserInputType.MouseButton1 and utility:MouseOverPosition({main_frame.Position,
main_frame.Position + v2new(main_frame.Size.X, 20)}) then
window.start = uis:GetMouseLocation() - main_frame.Position
window.dragging = true
end
end)
utility:Connect(uis.InputEnded, function(input)
if input.UserInputType == Enum.UserInputType.MouseButton1 then
window.dragging = false
end
end)
utility:Connect(uis.InputChanged, function(input)
Enum.UserInputType.MouseMovement and window.dragging then
main_frame.Position = uis:GetMouseLocation() - window.start
end
end)
local main_frame_outline = utility:Draw("Square", v2new(-1, -1), {

Size = main_frame.Size + v2new(2, 2),
Color = window.theme.outline,
Group = "outline",
Filled = false,
Parent = main_frame
})
local main_frame_accent = utility:Draw("Square", v2new(-2, -2), {

Size = main_frame.Size + v2new(4, 4),
Color = window.theme.accent,
Filled = false,
Group = "accent",
Parent = main_frame
})
local main_frame_title = utility:Draw("Text", v2new(3, 2), {

Font = 2,
Size = 13,
Outline = true,
Color = Color3.new(1, 1, 1),
Text = name,
Parent = main_frame
})
local pretab_frame = utility:Draw("Square", v2new(6, 20), {

Size = main_frame.Size - v2new(12, 26),
Color = window.theme.dcont,
Group = "dcont",
Parent = main_frame
})
local pretab_frame_inline = utility:Draw("Square", v2new(-1, -1), {

Size = pretab_frame.Size + v2new(2, 2),
Group = "dcont",
Filled = false,
Parent = pretab_frame
})
local pretab_frame_outline = utility:Draw("Square", v2new(-2, -2), {

Size = pretab_frame.Size + v2new(4, 4),
Color = c3rgb(),
Group = "outline",
Filled = false,
})
local tabs_frame = utility:Draw("Square", v2new(6, 23), {

Size = main_frame.Size - v2new(24, 55),
Group = "lcont",
})
local tab_frame_accent = utility:Draw("Square", v2zero, {

Size = v2new(0, 1),
Group = "accent",
ZIndex = 1
})
utility:Connect(rs.RenderStepped, function()
if main_frame.Visible and window.sshit then
local tab_frame = window.sshit.instances[1]
tab_frame_accent.Size = v2new(tab_frame.Size.X, 1)
tab_frame_accent.Position = tab_frame.Position
end
end)
local tabs_frame_outline = utility:Draw("Square", v2new(-1, -1), {

Size = tabs_frame.Size + v2new(2, 2),
Color = window.theme.outline2,
Group = "outline2",
Filled = false,
Parent = tabs_frame
})
function window.Tab(self, info)
local name = info.name or "tab"
local offset = v2new(0, -19)
local tab = {name = name, instances = {}, sections = {}, sides = {{}, {}},
on = false}
local count = 1
if #self.tabs > 0 then
count = #self.tabs + 1
offset = self.tabs[#self.tabs].instances[1].GetOffset() +
v2new(self.tabs[#self.tabs].instances[1].Size.X + 1, 0)
end
local tab_frame = utility:Draw("Square", offset, {

Size = v2new(utility:GetPlexSize(name) + 12, 18),
Parent = tabs_frame
})
local tab_frame_outline = utility:Draw("Square", v2new(-1, -1), {

Size = tab_frame.Size + v2new(2, 2),
Color = window.theme.outline2,
Group = "outline2",
Filled = false,
Parent = tab_frame
})
local tab_frame_text = utility:Draw("Text", v2new(tab_frame.Size.X / 2, 2),

{
Font = 2,
Size = 13,
Text = name,
Outline = true,
Center = true,
Parent = tab_frame
})
local tab_frame_hider = utility:Draw("Square", v2new(0, tab_frame.Size.Y),

{
Size = v2new(tab_frame.Size.X, 1),
Group = "lcont",
Parent = tab_frame
})
tab.instances = {tab_frame, tab_frame_outline, tab_frame_text,

tab_frame_hider}
table.insert(self.tabs, tab)
function tab.Show(self)
tab_frame.Color = window.theme.lcont
tab_frame_hider.Visible = true
for i, v in pairs(self.sections) do
v:Show()
end
self.on = true
self:Update()
end
function tab.Hide(self)
tab_frame.Color = window.theme.dcont
tab_frame_hider.Visible = false
v:Hide()
end
self.on = false
self:Update()
end
function tab.Update(self)
-- // loop for every side (left, right)
for sn, side in pairs(self.sides) do
-- // every section in it
for i, v in pairs(side) do
-- // update it's size
v:Update()
-- // count y offset
local offset = 12
-- // if its not first section
if i > 1 then
-- // last section_frame instance
local last_sframe = side[i - 1].instances[1]
-- // set new section_frame instance offset with counting

last section_frame offset (y) + size (y) + 16 (default offset)
offset = offset + last_sframe.GetOffset().Y +

last_sframe.Size.Y
end
-- // set offset
v.instances[1].SetOffset(v2new(sn == 1 and 6 or
tabs_frame.Size.X/2+6, offset))
end
end
tab_frame.Color = self.on and window.theme.lcont or window.theme.dcont
v:Update()
end
end
function tab.Section(self, info)

local name = info.name or "section"
local side = info.side or "left" side = tostring(side):lower()
local render_non_attached = info.rna or info.render_non_attached or
false
-- // side check
if side ~= "left" and side ~= "right" then

side = "left"
end
-- // section
local section = {name = name, side = side, instances = {}, scale = 0,

things = {buttons = {}, toggles = {}, textboxes = {}, dropdowns = {}, sliders = {},
colorpickers ={}, keybinds = {}, lists = {}}, rna = render_non_attached}
local section_frame
if section.rna then
section_frame = utility:Draw("Square", v2new(side == "left" and 6
or tabs_frame.Size.X/2 - 6, 16), {
Size = v2new(228, section.scale),
Color = window.theme.cont,
Group = "cont"
})
table.insert(window.rna, section)
else
section_frame = utility:Draw("Square", v2new(side == "left" and 6
or tabs_frame.Size.X/2 - 6, 16), {
Size = v2new(tabs_frame.Size.X / 2 - 12, section.scale),
Color = window.theme.cont,
Group = "cont",
Parent = tabs_frame
})
end
local section_inline = utility:Draw("Square", v2new(-1, -1), {

Size = section_frame.Size + v2new(2, 2),
Group = "outline",
Filled = false,
Parent = section_frame
})
local section_outline = utility:Draw("Square", v2new(-2, -2), {

Size = section_frame.Size + v2new(4, 4),
Group = "lcont",
Filled = false,
})
local section_accent = utility:Draw("Square", v2new(0, 0), {

Size = v2new(8, 2),
Group = "accent",
})
local section_title = utility:Draw("Text", v2new(9, -7), {

Font = 2,
Size = 13,
--Outline = true,
Text = name,
})
local section_title_bold = utility:Draw("Text", v2new(1, 0), {

Font = 2,
Size = 13,
Text = name,
Parent = section_title
})
local section_accent2 = utility:Draw("Square", v2new(11 + (#name * 7),

0), {
Size = v2new(section_frame.Size.X - (11 + (#name * 7)), 2),
Group = "accent",
})
function section.Show(self)
for i, v in pairs(self.instances) do
v.Visible = true
end
end
function section.Hide(self)
v.Visible = false
end
end
function section.NextObjectPosition(self)
return self.scale > 0 and self.scale or 10
end
function section.UpdateScale(self, number)
if self.scale == 0 then
self.scale = 10
end
self.scale = self.scale + number + 5

end
function section.Update(self)
local tside = tab.sides[self.side == "left" and 1 or 2]
section_frame.Size = v2new(self.rna and 228 or tabs_frame.Size.X /

2 - 12, table.find(tside, self) == #tside and tabs_frame.Size.Y -
(section_frame.GetOffset().Y+5) or self.scale > 0 and self.scale or 10)
section_inline.Size = section_frame.Size + v2new(2, 2)
section_outline.Size = section_inline.Size + v2new(2, 2)
section_accent2.Size = v2new(section_frame.Size.X - (11 + (#name *
7)), 2)
for i, v in pairs(self.things.lists) do
v:update()
end
for _, thing in pairs({"buttons", "dropdowns", "sliders",

"textboxes", "keybinds", "colorpickers", "toggles"}) do
for i, v in pairs(section.things[thing]) do
v:Update()
end
end
end
function section.SetPositionIHateMyselfAndIWannaDieOk(self, new_pos)

if self.rna then
section_frame.Position = new_pos
end
end
if self.rna then
section:SetPositionIHateMyselfAndIWannaDieOk(v2new(-1000, -1000))
end
if input.UserInputType == Enum.UserInputType.MouseMovement and
window.tooltip and main_frame.Visible and utility:MouseOverDrawing(section_frame)
then
local is_it_visible = false
if tab.on then
for i, v in pairs(section.things.toggles) do
if is_it_visible then break end
local toggle_frame = getupvalue(v.Update, 1)
if v.tt ~= "" and

utility:MouseOverPosition({section_frame.Position + v2new(0,
toggle_frame.GetOffset().Y), section_frame.Position + v2new(section_frame.Size.X,
toggle_frame.GetOffset().Y + 17)}) then
is_it_visible = true
window.tooltip:SetPosition(toggle_frame.Position +
v2new(0, 12))
window.tooltip:SetText(v.tt)
end
end
end
if not is_it_visible and tab.on then

window.tooltip:SetPosition(v2new(-1000, -1000))
end
elseif not utility:MouseOverDrawing(main_frame) and window.tooltip
then
window.tooltip:SetPosition(v2new(-1000, -1000))
end
end)
-- // same for colorpicker just function
function section._Keybind(self, info, offsets, parent, do_update,

pointer, name2)
local def = info.def or "unset"
local name = info.name
local flag = info.flag
local keybind = {value = def, flag = flag, pointer = pointer, name

= name, sname = name2, mode = "toggle", instances = {}, minst = {}, binding =
false}
if pointer then
library.pointers[pointer] = keybind
end
local keybind_frame = utility:Draw("Square", offsets[1], {

Size = v2new(40, 12),
Group = "lcont",
Parent = parent
})
local keybind_title = utility:Draw("Text", offsets[2], {

Font = 2,
Size = 13,
Color = c3rgb(255, 255, 255),
Outline = true,
Text = name,
Parent = parent
})
if not do_update then

keybind_title.Text = ""
end
local keybind_outline = utility:Draw("Square", v2new(-1, -1), {

Size = keybind_frame.Size + v2new(2, 2),
Group = "outline",
Filled = false,
Parent = keybind_frame
})
local keybind_gradient = utility:Draw("Image", v2zero, {

Size = keybind_frame.Size,
Transparency = 0.35,
})
local keybind_value = utility:Draw("Text",

v2new(keybind_frame.Size.X / 2, -1), {
Font = 2,
Size = 13,
Color = c3rgb(255, 255, 255),
Outline = true,
Center = true,
Text = keybind.value,
})
utility:Image(keybind_gradient, "https://i.imgur.com/j9y4dux.png")
function keybind.Get(self)
return {self.value, self.mode}
end
function keybind.SetOffset(self, offset)

keybind_frame.SetOffset(offset)
end
function keybind.Update(self)
keybind_value.Text = utility.short_keybind_names[self.value] or
self.value:upper()
if parent == section_frame then

self:SetOffset(v2new(parent.Size.X - 46, offsets[1].Y))
end
if window.kblist then
window.kblist:Update()
end
end
function keybind.Set(self, value)

self.value = value[1]
self.mode = value[2]
self:Update()
end
function keybind.AddToTable(self, input_name)

if keybind.value == input_name then
if keybind.mode == "toggle" then
if table.find(window.kbds, keybind.pointer) then
table.remove(window.kbds, table.find(window.kbds,
keybind.pointer))
else
table.insert(window.kbds, keybind.pointer)
end
else
table.insert(window.kbds, keybind.pointer)
end
end
end
end
function keybind.Close(self)
if #self.minst > 0 then
for i, v in pairs(self.minst) do
v.Remove()
end
table.clear(self.minst)
end
window.shit.keybind = nil
end
function keybind.Open(self)
window:HideUselessDumbassFuckingShitStopPastingMyCodePleaseYouAreSkidAndImGayILikeB
igBlackManOkNoProblemThisIsASexcretFuncteiotieitns4epoivi2n45obvi6j45bv74gvho4hgv48
7()
local mframe = utility:Draw("Square", v2new(0, 15), {

Group = "dcont",
Size = v2new(48, 5 + 26),
})
local mframe_outline = utility:Draw("Square", v2new(-1, -1), {

Group = "outline",
Size = mframe.Size + v2new(2, 2),
Filled = false,
Parent = mframe
})
local modes = {}
for i, v in pairs({"Toggle", "Hold"}) do
modes[i] = utility:Draw("Text", v2new(3, 2 + 14 * (i-1)), {

Font = 2,
Size = 13,
Color = self.mode == v:lower() and window.theme.accent
or c3rgb(255, 255, 255),
Group = "accent",
Outline = true,
Text = v,
Parent = mframe
})
end
self.minst = {mframe, mframe_outline, unpack(modes)}
window.shit.keybind = self
end
keybind:Set({keybind.value, "toggle"})
if not keybind.binding then
if input.UserInputType == Enum.UserInputType.MouseButton1
then
if main_frame.Visible and (tab.on or
table.find(window.rna, section)) and not
window:FakeRealMouseFuckingImAloneGoingToKillMyselfWithKnife(section) and
utility:MouseOverDrawing(keybind_frame) then
keybind.binding = true
keybind_value.Text = "..."
else
if #keybind.minst > 0 then
if utility:MouseOverDrawing(keybind.minst[1])
then
local offset = uis:GetMouseLocation().Y -
keybind.minst[1].Position.Y
if offset >= 22 then

keybind.mode = "hold"
else
keybind.mode = "toggle"
end
for i, v in pairs({keybind.minst[3],
keybind.minst[4]}) do
v.Color = keybind.mode ==
v.Text:lower() and window.theme.accent or c3rgb(255, 255, 255)
end
else
keybind:Close()
end
end
keybind:AddToTable(input.UserInputType.Name)
end
elseif input.UserInputType ==
Enum.UserInputType.MouseButton2 then
if main_frame.Visible and (tab.on or
table.find(window.rna, section)) and not
utility:MouseOverDrawing(keybind_frame) then
keybind:Open()
else
keybind:AddToTable(input.UserInputType.Name)
end
elseif input.UserInputType == Enum.UserInputType.Keyboard
then
keybind:AddToTable(input.KeyCode.Name)
end
else
if input.UserInputType == Enum.UserInputType.Keyboard then
if input.KeyCode ~= Enum.KeyCode.Escape then
keybind.binding = false
keybind:Set({input.KeyCode.Name, keybind.mode})
else
keybind:Set({"unset", keybind.mode})
end
elseif input.UserInputType ==
Enum.UserInputType.MouseButton1 or input.UserInputType ==
Enum.UserInputType.MouseButton2 then
keybind:Set({input.UserInputType.Name, keybind.mode})
end
end
end)
if not keybind.binding and keybind.mode == "hold" then
if input.UserInputType == Enum.UserInputType.MouseButton1
or input.UserInputType == Enum.UserInputType.MouseButton2 then
if keybind.value == input.UserInputType then
table.remove(window.kbds,
table.find(window.kbds, keybind.pointer))
end
end
end
elseif input.UserInputType == Enum.UserInputType.Keyboard
then
if keybind.value == input.KeyCode.Name then
table.remove(window.kbds,
table.find(window.kbds, keybind.pointer))
end
end
end
end
end
end)
keybind.instances = {keybind_frame, keybind_title, keybind_outline,

keybind_gradient, keybind_value}
self.instances = utility:Combine(self.instances, keybind.instances)
if do_update then
self:UpdateScale(13)
end
table.insert(section.things.keybinds, keybind)
return keybind
end
function section._Colorpicker(self, info, offsets, parent, do_update,

pointer, cptable)
local def = info.def or c3rgb(255, 0, 0)
local trans = info.trans or info.transparency
local deftrans = info.deftrans or info.defaultrans or 0
local callback = info.callback or function() end
local colorpicker = {value = def, name = name, trans = trans,

callback = callback, pointer = pointer, flag = flag, dvalues = {}, instances = {}}
if pointer then
library.pointers[pointer] = colorpicker
end
table.insert(cptable, colorpicker)
local cpframe = utility:Draw("Square", offsets[1], {

Size = v2new(30, 12),
Color = def,
Parent = parent
})
local cpframe_outline = utility:Draw("Square", v2new(-1, -1), {

Size = cpframe.Size + v2new(2, 2),
Group = "outline",
Filled = false,
Parent = cpframe
})
local cpframe_gradient = utility:Draw("Image", v2zero, {

Size = cpframe.Size,
Parent = cpframe
})
local cptitle = utility:Draw("Text", offsets[2], {

Font = 2,
Size = 13,
Color = c3rgb(255, 255, 255),
Outline = true,
Text = name,
Parent = parent
})
utility:Image(cpframe_gradient, "https://i.imgur.com/j9y4dux.png")
if not do_update then

cptitle.Text = ""
end
function colorpicker.Get(self)
return not self.trans and {self.value:ToHSV()} or
{{self.value[1]:ToHSV()}, self.value[2]}
end
function colorpicker.SetOffset(self, offset)

cpframe.SetOffset(offset)
end
function colorpicker.Update(self)
cpframe.Color = self.trans and self.value[1] or self.value
if parent == section_frame then

self:SetOffset(v2new(parent.Size.X - 36, offsets[1].Y))
end
end
function colorpicker.Set(self, value)
self.value = not self.trans and c3hsv(unpack(value)) or

{c3hsv(value[1][1], value[1][2], value[1][3]), value[2]}
if colorpicker.flag ~= nil then

library.flags[flag] = self.value
end
self:Update()
self.callback(self.value)
end
function colorpicker.Close(self)
if #self.instances > 0 then
v.Remove()
end
self.instances = {}
window.shit.colorpicker = nil
end
end
function colorpicker.Open(self)
window:HideUselessDumbassFuckingShitStopPastingMyCodePleaseYouAreSkidAndImGayILikeB
7()
local hsv = (self.trans and {self.value[1]:ToHSV()}) or

{self.value:ToHSV()}
self.dvalues = {hsv[1], hsv[2], hsv[3], self.trans and

self.value[2] or 0, false, false, false}
local cpdropframe = utility:Draw("Square", v2new(35, 0), {

Group = "dcont",
Size = v2new(self.trans and 152 or 137, 120),
Parent = cpframe
})
local cpdropframe_outline = utility:Draw("Square", v2new(-1, -
1), {
Group = "outline",
Size = cpdropframe.Size + v2new(2, 2),
Filled = false,
Parent = cpdropframe
})
local cpdropframe_accent = utility:Draw("Square", v2zero, {

Group = "accent",
Size = v2new(cpdropframe.Size.X, 1),
})
local cpdropframe_color = utility:Draw("Square", v2new(10, 10),

{
Color = c3hsv(self.dvalues[1], 1, 1),
Size = v2new(100, 100),
})
local cpdropframe_color_outline = utility:Draw("Square",

v2new(-1, -1), {
Group = "outline",
Size = cpdropframe_color.Size + v2new(2, 2),
Filled = false,
Parent = cpdropframe_color
})
local cpdropframe_color_image = utility:Draw("Image", v2zero, {

Size = cpdropframe_color.Size,
})
local cpdropframe_color_cursor = utility:Draw("Square",

v2new(math.clamp(self.dvalues[2]*100, 0, 97), math.clamp((1-self.dvalues[3])*100,
0, 97)), {
Color = c3rgb(255, 255, 255),
Size = v2new(3, 3),
})
local cpdropframe_color_cursor_outline = utility:Draw("Square",

v2new(-1, -1), {
Group = "outline",
Size = cpdropframe_color_cursor.Size + v2new(2, 2),
Filled = false,
Parent = cpdropframe_color_cursor
})
local cpdropframe_hue = utility:Draw("Square", v2new(120, 10),

{
Group = "outline",
Size = v2new(7, 100),
Filled = false,
})
local cpdropframe_hue_image = utility:Draw("Image", v2new(1,

1), {
Size = cpdropframe_hue.Size - v2new(2, 2),
Parent = cpdropframe_hue
})
local cpdropframe_hue_picker = utility:Draw("Square", v2new(0,

math.clamp(math.floor(self.dvalues[1]*100), 0, 99)), {
Color = c3rgb(255, 255, 255),
Size = v2new(7, 1),
Parent = cpdropframe_hue
})
local cpdropframe_hue_picker_outline = utility:Draw("Square",

v2new(-1, -1), {
Group = "outline",
Size = cpdropframe_hue_picker.Size + v2new(2, 2),
Filled = false,
Parent = cpdropframe_hue_picker
})
local cpdropframe_trans = utility:Draw("Square", v2new(137,

10), {
Group = "outline",
Size = v2new(7, 100),
Filled = false,
})
local cpdropframe_trans_image = utility:Draw("Image", v2new(1,

1), {
Size = cpdropframe_trans.Size - v2new(2, 2),
Parent = cpdropframe_trans
})
local cpdropframe_trans_picker = utility:Draw("Square",

v2new(0, math.clamp(math.floor(self.dvalues[4]*100), 0, 99)), {
Color = c3rgb(255, 255, 255),
Size = v2new(7, 1),
Parent = cpdropframe_trans
})
local cpdropframe_trans_picker_outline = utility:Draw("Square",

v2new(-1, -1), {
Group = "outline",
Size = cpdropframe_trans_picker.Size + v2new(2, 2),
Filled = false,
Parent = cpdropframe_trans_picker
})
if not self.trans then

cpdropframe_trans.Visible = false
cpdropframe_trans_image.Visible = false
cpdropframe_trans_picker.Visible = false
cpdropframe_trans_picker_outline.Visible = false
end
utility:Image(cpdropframe_color_image,
"https://i.imgur.com/wpDRqVH.png")
utility:Image(cpdropframe_hue_image,
"https://i.imgur.com/iEOsHFv.png")
utility:Image(cpdropframe_trans_image,
"https://i.imgur.com/GeMU2Ke.png")
self.instances = {cpdropframe, cpdropframe_outline,

cpdropframe_accent, cpdropframe_color, cpdropframe_color_outline,
cpdropframe_color_image,
cpdropframe_color_cursor, cpdropframe_color_cursor_outline,
cpdropframe_hue, cpdropframe_hue_image, cpdropframe_hue_picker,
cpdropframe_hue_picker_outline,
cpdropframe_trans, cpdropframe_trans_image,
cpdropframe_trans_picker, cpdropframe_trans_picker_outline
}
window.shit.colorpicker = self
end
function colorpicker.Colorpicker(self, info)
self.doublecp = true
return section:_Colorpicker(info, {v2new(-35, 0) , v2zero},

cpframe, false, pointer .. "Colorpicker", cptable)
end
colorpicker:Set(colorpicker.trans and {{colorpicker.value:ToHSV()},

deftrans} or {colorpicker.value:ToHSV()})
if main_frame.Visible and (tab.on or table.find(window.rna,
section)) then
if not
utility:MouseOverDrawing(cpframe) then
colorpicker:Open()
else
if #colorpicker.instances > 0 then
if
utility:MouseOverDrawing(colorpicker.instances[1]) then
if
local offset = uis:GetMouseLocation() -
colorpicker.instances[4].Position
local size =
colorpicker.instances[4].Size
local px, py = offset.X / size.X,

offset.Y / size.Y
px, py = math.clamp(px, 0, 1),
math.clamp(py, 0, 1)
local mno, mxo = v2zero, size -

v2new(4, 4)
local posx, posy =

math.floor(math.clamp(px * size.X, mno.X, mxo.X)), math.floor(math.clamp(py *
size.Y, mno.Y, mxo.Y))
colorpicker.instances[7].SetOffset(v2new(posx, posy))
colorpicker.dvalues[2] = px
colorpicker.dvalues[3] = 1-py
colorpicker.dvalues[5] = true
elseif
local offset = uis:GetMouseLocation().Y
- colorpicker.instances[9].Position.Y
local size =
colorpicker.instances[9].Size.Y
local py = math.clamp(offset / size, 0,

1)
colorpicker.instances[11].SetOffset(v2new(0, math.clamp(math.floor(py*size), 0,
size-1)))
colorpicker.instances[4].Color =
c3hsv(py, 1, 1)
colorpicker.dvalues[1] = py
elseif
utility:MouseOverDrawing(colorpicker.instances[13]) and colorpicker.trans then
local offset = uis:GetMouseLocation().Y
- colorpicker.instances[13].Position.Y
local size =
colorpicker.instances[13].Size.Y
local py = math.clamp(offset / size, 0,

1)
colorpicker.instances[15].SetOffset(v2new(0, math.clamp(math.floor(py*size), 0,
size-1)))
end
local dvalues = colorpicker.dvalues

local color = c3hsv(dvalues[1], dvalues[2],
dvalues[3])
colorpicker:Set(colorpicker.trans and
{{color:ToHSV()}, dvalues[4]} or {color:ToHSV()})
else
colorpicker:Close()
end
else
colorpicker:Close()
end
end
end
end
end)
#colorpicker.instances > 0 then
if main_frame.Visible and (tab.on or table.find(window.rna,
section)) then
if colorpicker.dvalues[5] then
local mouse_pos = uis:GetMouseLocation()
local offset = mouse_pos -
local size = colorpicker.instances[4].Size
local px, py = offset.X / size.X, offset.Y / size.Y
px, py = math.clamp(px, 0, 1), math.clamp(py, 0, 1)
local mno, mxo = v2zero, size - v2new(4, 4)
local posx, posy = math.floor(math.clamp(px *

size.X, mno.X, mxo.X)), math.floor(math.clamp(py * size.Y, mno.Y, mxo.Y))
colorpicker.instances[7].SetOffset(v2new(posx,
posy))
elseif colorpicker.dvalues[6] then
colorpicker.instances[9].Position.Y
local size = colorpicker.instances[9].Size.Y
local py = math.clamp(offset / size, 0, 1)
colorpicker.instances[11].SetOffset(v2new(0,
math.clamp(math.floor(py*size), 0, size-1)))
colorpicker.instances[4].Color = c3hsv(py, 1, 1)
end

local color = c3hsv(dvalues[1], dvalues[2], dvalues[3])
colorpicker:Set(colorpicker.trans and {{color:ToHSV()},

dvalues[4]} or {color:ToHSV()})
end
end
end)
if input.UserInputType == Enum.UserInputType.MouseButton1 and
#colorpicker.instances > 0 then
if colorpicker.dvalues[5] then
local mouse_pos = uis:GetMouseLocation()

local offset = mouse_pos -
local size = colorpicker.instances[4].Size
local px, py = offset.X / size.X, offset.Y / size.Y
px, py = math.clamp(px, 0, 1), math.clamp(py, 0, 1)
local mno, mxo = v2zero, size - v2new(4, 4)
local posx, posy = math.floor(math.clamp(px * size.X,

mno.X, mxo.X)), math.floor(math.clamp(py * size.Y, mno.Y, mxo.Y))
colorpicker.instances[7].SetOffset(v2new(posx, posy))
colorpicker.dvalues[5] = false
colorpicker.instances[4].Color = c3hsv(py, 1, 1)
end

local color = c3hsv(dvalues[1], dvalues[2], dvalues[3])
colorpicker:Set(colorpicker.trans and {{color:ToHSV()},

dvalues[4]} or {color:ToHSV()})
end
end)
self.instances = utility:Combine(self.instances, {cpframe, cptitle,

cpframe_outline, cpframe_gradient})
if do_update then
end
table.insert(self.things.colorpickers, colorpicker)
return colorpicker
end
function section.Button(self, info)
local name = info.name or "Button"

local button = {name = name, callback = callback}
local button_frame = utility:Draw("Square", v2new(6,

self:NextObjectPosition()), {
Size = v2new(section_frame.Size.X - 12, 18),
Group = "lcont",
})
local button_outline = utility:Draw("Square", v2new(-1, -1), {

Size = button_frame.Size + v2new(2, 2),
Group = "outline",
Filled = false,
Parent = button_frame
})
local button_gradient = utility:Draw("Image", v2zero, {
Size = button_frame.Size,
})
local button_title = utility:Draw("Text", v2new(button_frame.Size.X

/ 2, 2), {
Font = 2,
Size = 13,
Outline = true,
Center = true,
Text = name,
})
utility:Image(button_gradient, "https://i.imgur.com/j9y4dux.png")
function button.Update(self)
button_frame.Size = v2new(section_frame.Size.X - 12, 18)
button_outline.Size = button_frame.Size + v2new(2, 2)
button_gradient.Size = button_frame.Size
button_title.SetOffset(v2new(button_frame.Size.X/2, 2))
end
main_frame.Visible and tab.on and not
button_frame.GetOffset().Y), section_frame.Position + v2new(section_frame.Size.X,
button_frame.GetOffset().Y + 18)}) then
button.callback()
end
end)
self.instances = utility:Combine(self.instances, {button_frame,

button_outline, button_title, button_gradient})
table.insert(self.things.buttons, button)
end
function section.Textbox(self, info)

local def = info.default or info.def or ""
local pointer = tab.name .. section.name .. name
local textbox = {name = name, typing = false, value = def, callback

= callback, flag = flag, pointer = pointer}
if pointer then
library.pointers[pointer] = textbox
end
local textbox_frame = utility:Draw("Square", v2new(6,
self:NextObjectPosition()), {
Group = "lcont",
})
local textbox_outline = utility:Draw("Square", v2new(-1, -1), {

Size = textbox_frame.Size + v2new(2, 2),
Group = "outline",
Filled = false,
Parent = textbox_frame
})
local textbox_gradient = utility:Draw("Image", v2zero, {

Size = textbox_frame.Size,
})
local textbox_title = utility:Draw("Text", v2new(4, 2), {

Font = 2,
Size = 13,
Color = c3rgb(255, 255, 255),
Outline = true,
Text = name,
})
utility:Image(textbox_gradient, "https://i.imgur.com/j9y4dux.png")
function textbox.Update(self)
textbox_frame.Size = v2new(section_frame.Size.X - 12, 18)
textbox_outline.Size = textbox_frame.Size + v2new(2, 2)
textbox_gradient.Size = textbox_frame.Size
local max = math.floor(textbox_frame.Size.X/7)-3
if self.value == "" then

textbox_title.Color = c3rgb(170, 170, 170)
local sub = self.name:sub(1, max)
textbox_title.Text = sub .. (#self.name > max and "..." or

"")
else
textbox_title.Color = c3rgb(255, 255, 255)
local sub = self.value:sub(1, max)
textbox_title.Text = sub .. (#self.value > max and "..." or

"")
end
end
function textbox.Get(self)
return self.value
end
function textbox.Start(self)
self.typing = true
window.shit.textbox = self
end
function textbox.Stop(self)
self.typing = false
window.shit.textbox = nil
end
function textbox.Set(self, value)

self.value = value
if self.flag then
library.flags[self.flag] = value
end
self:Update()
end
textbox:Set(textbox.value)
main_frame.Visible and tab.on then
if not
textbox_frame.GetOffset().Y), section_frame.Position + v2new(section_frame.Size.X,
textbox_frame.GetOffset().Y + 18)}) then
textbox:Start()
else
textbox:Stop()
end
elseif input.UserInputType == Enum.UserInputType.Keyboard and
textbox.typing then
local keycode = input.KeyCode
local key_name = uis:GetStringForKeyCode(keycode):lower()
if uis:IsKeyDown("LeftShift") or
uis:IsKeyDown("RightShift") then
key_name = utility:ShiftKey(key_name)
end
if keycode.Name ~= "Backspace" then

if key_name ~= "" then
textbox:Set(textbox.value .. key_name)
end
else
textbox:Set(textbox.value:sub(1, -2))
end
end
end)
self.instances = utility:Combine(self.instances, {textbox_frame,
textbox_outline, textbox_gradient, textbox_title})
table.insert(self.things.textboxes, textbox)
return textbox
end
function section.Toggle(self, info)
local name = info.name or "toggle"

local default = info.default or info.def or false
local tooltip = info.tooltip or info.ttip or info.tt or ""
local pointer = info.pointer or tab.name .. section.name .. name
local toggle = {name = name, flag = flag, state = default, callback

= callback, tt = tooltip, pointer = pointer}
if toggle.pointer then
library.pointers[pointer] = toggle
end
local toggle_frame = utility:Draw("Square", v2new(6,

self:NextObjectPosition() + 3), {
Size = v2new(8, 8),
})
local toggle_outline = utility:Draw("Square", v2new(-1, -1), {

Size = toggle_frame.Size + v2new(2, 2),
Group = "outline",
Filled = false,
Parent = toggle_frame
})
local toggle_gradient = utility:Draw("Image", v2zero, {

Size = toggle_frame.Size,
})
local toggle_title = utility:Draw("Text", v2new(13, -3), {

Font = 2,
Size = 13,
Outline = true,
Text = name,
})
utility:Image(toggle_gradient, "https://i.imgur.com/j9y4dux.png")
function toggle.Get(self)
return self.state
end
function toggle.Update(self)
toggle_frame.Color = self.state and window.theme.accent or
window.theme.lcont
if self.keybind then
self.keybind:SetOffset(v2new(section_frame.Size.X - (45+8),
-1))
end
if self.fcp then
self.fcp:SetOffset(v2new(section_frame.Size.X - (35+8), -
1))
end
if self.flag then
library.flags[self.flag] = self.state
end
end
function toggle.Set(self, state)

self.state = state
self:Update()
self.callback(self.state)
end
function toggle.Keybind(self, info)

info.name = self.name
self.keybind = section:_Keybind(info,
{v2new(section_frame.Size.X - (45+8), -1), v2new()}, toggle_frame, false,
tab.name .. section.name .. info.name .. "Keybind", section.name)
self.kexs = true
return self.keybind
end
function toggle.Colorpicker(self, info)

info.name = self.name
self.cps = {}
self.fcp = section:_Colorpicker(info,
{v2new(section_frame.Size.X - (35+8), -1), v2new()}, toggle_frame, false,
tab.name .. section.name .. info.name .. "Colorpicker", self.cps)
return self.fcp
end
toggle:Set(default)
local offset = (toggle.kexs and section_frame.Size.X - 46) or
(toggle.cps ~= nil and section_frame.Size.X - (1 + (#toggle.cps*35))) or
section_frame.Size.X

main_frame.Visible and (tab.on or table.find(window.rna, section)) and not
toggle_frame.GetOffset().Y), section_frame.Position + v2new(offset,
toggle_frame.GetOffset().Y + 17)}) then
toggle:Set(not toggle.state)
end
end)
self.instances = utility:Combine(self.instances, {toggle_frame,

toggle_outline, toggle_title, toggle_gradient})
table.insert(self.things.toggles, toggle)
return toggle
end
function section.Slider(self, info)

info = info or {}
local name = info.name or "slider"

local min = info.min or 1
local max = info.max or 100
local def = info.def or min
local dec = info.dec or 1
local suf = info.suf or ""
local mintval = info.mintval or info.min_text_value
local maxtval = info.maxtval or info.max_text_value
local flag = info.flag or ""
local slider = {name = name, flag = flag, pointer = pointer, value

= def, min = min, max = max, suf = suf, dec = dec, mintval = mintval, maxtval =
maxtval, holding = false, callback = callback}
if pointer then
library.pointers[pointer] = slider
end
local slider_title = utility:Draw("Text", v2new(6,

Color = c3rgb(255, 255, 255),
Outline = true,
Size = 13,
Font = 2,
Text = name,
})
local slider_pm = utility:Draw("Text", v2new(section_frame.Size.X-

33, 0), {
Color = c3rgb(255, 255, 255),
Outline = true,
Size = 13,
Font = 2,
Text = "- +",
Parent = slider_title
})
local slider_frame = utility:Draw("Square", v2new(0, 16), {

Group = "lcont",
Parent = slider_title
})
local slider_outline = utility:Draw("Square", v2new(-1, -1), {

Size = slider_frame.Size + v2new(2, 2),
Group = "outline",
Filled = false,
Parent = slider_frame
})
local slider_bar = utility:Draw("Square", v2new(), {

Size = v2new(0, slider_frame.Size.Y),
Group = "accent",
})
local slider_gradient = utility:Draw("Image", v2new(), {

Size = slider_frame.Size,
Transparency = .75,
})
local slider_value = utility:Draw("Text", v2new(slider_frame.Size.X

/ 2, -2), {
Color = c3rgb(255, 255, 255),
Outline = true,
Size = 13,
Font = 2,
Text = tostring(def) .. "/" .. tostring(max) .. suf,
Center = true,
})
utility:Image(slider_gradient, "https://i.imgur.com/j9y4dux.png")
function slider.Get(self)
return self.value
end
function slider.Update(self)
slider_frame.Size = v2new(section_frame.Size.X - 12, 10)
slider_outline.Size = slider_frame.Size + v2new(2, 2)
slider_gradient.Size = slider_frame.Size
slider_value.SetOffset(v2new(slider_frame.Size.X/2, -2))
slider_pm.SetOffset(v2new(section_frame.Size.X-33, 0))
slider_value.Text = self.mintval and self.value == self.min and

self.mintval or self.maxtval and self.value == self.max and self.maxtval or ("%s
%s"):format(tostring(self.value), tostring(slider.suf))
local percent = 1 - (self.max - self.value) / (self.max -

self.min)
slider_bar.Size = v2new(percent * slider_frame.Size.X,

slider_frame.Size.Y)
if self.flag then
library.flags[self.flag] = self.value
end
end
function slider.Set(self, value)

self.value = value
self:Update()
callback(self.value)
end
slider:Set(slider.value)
slider_title.GetOffset().Y), section_frame.Position + v2new(section_frame.Size.X,
slider_title.GetOffset().Y + 29)}) then
if utility:MouseOverPosition({section_frame.Position +
v2new(section_frame.Size.X-27, slider_title.GetOffset().Y), section_frame.Position
+ v2new(section_frame.Size.X, slider_title.GetOffset().Y+14)}) then
local offset = uis:GetMouseLocation().X -
slider_pm.Position.X
if offset < 15 then
slider:Set(math.clamp(math.floor((slider.value - (1
/ slider.dec)) * slider.dec) / slider.dec, slider.min, slider.max))
elseif offset > 15 then
local value_fix = (slider.value + (1 / slider.dec))
if value_fix % (1 / slider.dec) ~= 0 then

value_fix = math.round(value_fix * (slider.dec
* 10)) / (slider.dec * 10)
end
slider:Set(math.clamp(math.floor(value_fix *
slider.dec) / slider.dec, slider.min, slider.max))
end
else
slider.holding = true
local percent = math.clamp(uis:GetMouseLocation().X -
slider_bar.Position.X, 0, slider_frame.Size.X) / slider_frame.Size.X
local value = math.floor((slider.min + (slider.max -
slider.min) * percent) * slider.dec) / slider.dec
value = math.clamp(value, slider.min, slider.max)
slider:Set(value)
end
end
end)
slider.holding then
slider:Set(value)
end
end)
slider.holding then
slider.holding = false
slider:Set(value)
end
end)
slider.instances = {slider_title, slider_frame, slider_outline,

slider_bar, slider_gradient, slider_value, slider_pm}
self.instances = utility:Combine(self.instances, slider.instances)
table.insert(self.things.sliders, slider)
return slider
end
function section.Dropdown(self, info)

info = info or {}
local name = info.name or "dropdown"

local options = info.options or {"first", "second", "third"}
local multi = info.multi or false
local def = info.default or info.def or (not multi and options[1]
or {options[1]})
local minOptions = info.min or info.minOptions or 1
local scrollable = info.scrollable or false
local visOptions = (scrollable and info.vis) or #options
local flag = info.flag or ""
local pointer = tab.name .. section.name .. name
local dropdown = {name = name, multi = multi, options = options,

value = def, minOptions = minOptions, scrollable = scrollable, visOptions =
visOptions, scrolling = {1, visOptions}, instances = {}, callback = callback, flag
= flag, pointer = pointer}
if pointer then
library.pointers[pointer] = dropdown
end
local dropdown_title = utility:Draw("Text", v2new(6,

Color = c3rgb(255, 255, 255),
Outline = true,
Size = 13,
Font = 2,
Text = name,
})
local dropdown_frame = utility:Draw("Square", v2new(0, 17), {

Group = "lcont",
Parent = dropdown_title
})
local dropdown_outline = utility:Draw("Square", v2new(-1, -1), {

Size = dropdown_frame.Size + v2new(2, 2),
Group = "outline",
Filled = false,
Parent = dropdown_frame
})
local dropdown_gradient = utility:Draw("Image", v2zero, {

Size = dropdown_frame.Size,
})
local dropdown_value = utility:Draw("Text", v2new(4, 2), {

Color = c3rgb(255, 255, 255),
Outline = true,
Size = 13,
Font = 2,
Text = "shit vaLue",
})
local dropdown_image = utility:Draw("Image",

v2new(dropdown_frame.Size.X - 14, 6), {
Size = v2new(9, 6),
})
utility:Image(dropdown_gradient, "https://i.imgur.com/j9y4dux.png")
utility:Image(dropdown_image, "https://i.imgur.com/tVqy0nL.png")
function dropdown.Get(self)
return self.value
end
function dropdown.Refresh(self, new)
self.options = new
end
function dropdown.Open(self)
self.scrolling[1] = 1
self.scrolling[2] = self.visOptions
local list_frame = utility:Draw("Square", v2new(0, 19), {

Size = v2new(dropdown_frame.Size.X, 2+16*#self.options),
Group = "dcont",
})
if self.scrollable and #self.options > self.visOptions then

list_frame.Size = v2new(dropdown_frame.Size.X,
2+16*self.visOptions)
end
local list_outline = utility:Draw("Square", v2new(-1, -1), {

Size = list_frame.Size + v2new(2, 2),
Group = "outline",
Filled = false,
Parent = list_frame
})
local list_scrollbar = utility:Draw("Square",

v2new(list_frame.Size.X-3, 0), {
Size = v2new(3, list_frame.Size.Y/(#self.options -
self.visOptions + 1)),
Group = "accent",
Parent = list_frame
})
if not self.scrollable or (self.scrollable and #self.options <=

self.visOptions) then
list_scrollbar.Visible = false
end
self.instances = {list_frame, list_outline, list_scrollbar}
for i, v in pairs(self.options) do
local option_text = utility:Draw("Text", v2new(4, 2+16*(i-
1)), {
Color = (multi and table.find(self.value, v) or not
multi and self.value == v) and window.theme.accent or c3rgb(255, 255, 255),
Outline = true,
Size = 13,
Font = 2,
Text = tostring(v),
Parent = list_frame
})
if self.scrollable then
if i >= self.scrolling[1] and i <= self.scrolling[2]
then
option_text.Visible = true
else
option_text.Visible = false
end
end
table.insert(self.instances, option_text)
end
utility:Image(dropdown_image,
"https://i.imgur.com/SL9cbQp.png")
window.shit.dropdown = dropdown
end
function dropdown.Close(self)
for _, v in pairs(self.instances) do
v.Remove()
end
self.instances = {}
utility:Image(dropdown_image,
"https://i.imgur.com/tVqy0nL.png")
window.shit.dropdown = nil
end
function dropdown.GenerateValueName(self)
if not self.multi then
local text_size = utility:GetPlexSize(self.value)
local max_size = dropdown_frame.Size.X - (4+16)
if text_size < max_size then

return self.value
else
return self.value:sub(1, 25) .. "..."
end
else
local text = ""
for i, v in pairs(self.value) do
if i ~= #self.value then
text = text .. v .. ", "
else
text = text .. v
end
end
local text_size = utility:GetPlexSize(text)
local max_size = dropdown_frame.Size.X - (4+16)
if text_size < max_size then

return text
else
return text:sub(1, 25) .. "..."
end
end
end
function dropdown.Update(self)
dropdown_frame.Size = v2new(section_frame.Size.X - 12, 18)
dropdown_outline.Size = dropdown_frame.Size + v2new(2, 2)
dropdown_gradient.Size = dropdown_frame.Size
dropdown_image.SetOffset(v2new(dropdown_frame.Size.X - 14, 6))
if #self.instances > 1 then

self.instances[1].Size = v2new(dropdown_frame.Size.X,
self.instances[1].Size.Y)
self.instances[2].Size = self.instances[1].Size + v2new(2,
2)
for i, v in pairs({select(4, unpack(self.instances))}) do

if multi and table.find(self.value, v.Text) or not
multi and self.value == v.Text then
v.Color = window.theme.accent
else
v.Color = c3rgb(255, 255, 255)
end
if self.scrollable then
if i >= self.scrolling[1] and i <=
self.scrolling[2] then
v.Visible = true
v.SetOffset(v2new(4, 2+16*(i-
self.scrolling[1])))
else
v.Visible = false
end
end
end
local max_y_pos = self.instances[1].Size.Y -

self.instances[3].Size.Y
self.instances[3].SetOffset(v2new(self.instances[1].Size.X-
self.instances[3].Size.X, max_y_pos * ((1/(#self.options-
self.visOptions))*(self.scrolling[1]-1))))
end
end
function dropdown.Set(self, value)

self.value = value
dropdown_value.Text = self:GenerateValueName()
self:Update()
self.callback(self.value)
end
dropdown:Set(dropdown.value)
main_frame.Visible and (tab.on or table.find(window.rna, section)) then
if #dropdown.instances > 1 then
if utility:MouseOverDrawing(dropdown.instances[1]) then
local option_counter = (uis:GetMouseLocation().Y -
(dropdown.instances[1].Position.Y+2))/16
if option_counter%1 ~= 0 then
option_counter = math.floor(option_counter)+1
end
option_counter = option_counter > 0 and

option_counter or 1
if dropdown.scrollable then
option_counter = dropdown.scrolling[1] +
option_counter - 1
end
if not dropdown.multi then

dropdown:Set(dropdown.options[option_counter])
else
local value = dropdown.options[option_counter]
if table.find(dropdown.value, value) then

if #dropdown.value > dropdown.minOptions
then
table.remove(dropdown.value,
table.find(dropdown.value, value))
end
else
table.insert(dropdown.value, value)
end
dropdown:Set(dropdown.value)
end
else
dropdown:Close()
end
else
if not
dropdown_title.GetOffset().Y), section_frame.Position + v2new(section_frame.Size.X,
dropdown_title.GetOffset().Y + 35)}) then
dropdown:Open()
end
end
end
end)
if input.UserInputType == Enum.UserInputType.MouseWheel and
#dropdown.instances > 1 and utility:MouseOverDrawing(dropdown.instances[1]) and
#dropdown.options > dropdown.visOptions then
local direction = input.Position.Z > 0 and "up" or "down"
local min, max = dropdown.scrolling[1],
dropdown.scrolling[2]
if direction == "up" then

dropdown.scrolling[1] = min ~= 1 and min - 1 or min
dropdown.scrolling[2] = min ~= 1 and max - 1 or max
else
dropdown.scrolling[1] = max ~= #dropdown.options and
min + 1 or min
dropdown.scrolling[2] = max ~= #dropdown.options and
max + 1 or max
end
dropdown:Update()
end
end)
self.instances = utility:Combine(self.instances, {dropdown_title,

dropdown_frame, dropdown_outline, dropdown_gradient, dropdown_value,
dropdown_image})
table.insert(self.things.dropdowns, dropdown)
return dropdown
end
function section.Keybind(self, info)

return self:_Keybind(info, {v2new(section_frame.Size.X - 46,
self:NextObjectPosition() + 2), v2new(6, self:NextObjectPosition())},
section_frame, true, tab.name .. section.name .. info.name, section.name)
end
function section.Colorpicker(self, info)

return self:_Colorpicker(info, {v2new(section_frame.Size.X - 36,
self:NextObjectPosition() + 2), v2new(6, self:NextObjectPosition())},
section_frame, true, tab.name .. section.name .. info.name, {})
end
function section.List(self, info)

info = info or {}
local name = info.name or "list"

local options = info.options or {"option 1", "option 2"}
local def = info.def or info.default or options[1]
local list = {name = name, value = def, scroll = {}, options =

options, flag = flag, pointer = pointer, opinst = {}, lloop = nil}
if pointer then
library.pointers[pointer] = list
end
local list_title = utility:Draw("Text", v2new(6,

self:NextObjectPosition()-2), {
Color = c3rgb(255, 255, 255),
Outline = true,
Size = 13,
Font = 2,
Text = name,
})
local list_frame = utility:Draw("Square", v2new(0, 15), {

Group = "dcont",
Parent = list_title
})
local list_frame_outline = utility:Draw("Square", v2new(-1, -1), {

Group = "outline",
Size = list_frame.Size + v2new(2, 2),
Filled = false,
Parent = list_frame
})
local list_frame_scrollbar = utility:Draw("Square",

v2new(list_frame.Size.X-3, 0), {
Group = "accent",
Size = v2new(3, 0),
Parent = list_frame
})
function list.fix_string(self, value)

local max_symbols = math.floor(list_frame.Size.X/7)
return #value < max_symbols and value or value:sub(1,

max_symbols-3) .. "..."
end
function list.draw_options(self)
for i, v in pairs(self.opinst) do
v.Remove()
end
table.clear(self.opinst)
self.scroll = {1, 10}
for i, text in pairs(self.options) do
local list_option = utility:Draw("Text", v2new(3, (i-

1)*14), {
Color = self.value == text and window.theme.accent or
c3rgb(255, 255, 255),
Outline = true,
Size = 13,
Font = 2,
Text = self:fix_string(text),
Visible = i >= self.scroll[1] and i <= self.scroll[2],
Parent = list_frame
})
table.insert(self.opinst, list_option)
end
self:update()
end
function list.update(self)
list_frame.Size = v2new(section_frame.Size.X - 12, 140)
list_frame_outline.Size = list_frame.Size + v2new(2, 2)
for i, v in pairs(self.opinst) do
v.Visible = list_frame.Visible and i >= self.scroll[1] and
i <= self.scroll[2]
if v.Visible then
v.Color = self.value == self.options[i] and
window.theme.accent or c3rgb(255, 255, 255)
v.SetOffset(v2new(3, (i - self.scroll[1])*14))
end
end
list_frame_scrollbar.Visible = list_frame.Visible and

#self.options > 10 and true or false
list_frame_scrollbar.Size = v2new(3, list_frame.Size.Y / (1 +
#self.options - 10))
if self.lloop then
self.lloop:Disconnect()
self.lloop = nil
end
local elapsed, from, to = 0,

list_frame_scrollbar.GetOffset().Y, ((1/(#self.options-10)*(self.scroll[1]-
1)))*(list_frame.Size.Y-list_frame_scrollbar.Size.Y)
local loop; loop = utility:Connect(rs.Heartbeat,

function(delta)
if elapsed == 0.1 then
list_frame_scrollbar.SetOffset(v2new(list_frame.Size.X-
3, to))
loop:Disconnect()
end
local ptc = (elapsed/0.1)^3
list_frame_scrollbar.SetOffset(v2new(list_frame.Size.X-3,
from + (to-from) * ptc))
elapsed = math.clamp(elapsed + delta, 0, 0.1)

end)
self.lloop = loop
end
function list.Refresh(self, new_options)
self.options = new_options
self:draw_options()
end
function list.Get(self)
return self.value
end
function list.Set(self, value)

self.value = value
if self.flag then
end
self:update()
end
utility:MouseOverDrawing(list_frame) then
list_frame.Position.Y
local option_index = math.clamp(offset/14, 1, 10)
if option_index % 1 ~= 0 then
option_index = math.floor(option_index) + 1
end
local index = list.scroll[1] - 1 + option_index
if list.options[index] then
list:Set(list.options[index])
end
end
end)
if input.UserInputType == Enum.UserInputType.MouseWheel and
utility:MouseOverDrawing(list_frame) then
local direction = input.Position.Z > 0 and "up" or "down"
local min, max = list.scroll[1], list.scroll[2]
if direction == "up" then

list.scroll[1] = min ~= 1 and min - 1 or min
list.scroll[2] = min ~= 1 and max - 1 or max
else
list.scroll[1] = max ~= #list.options and min + 1 or
min
list.scroll[2] = max ~= #list.options and max + 1 or
max
end
list:update()
end
end)
list:draw_options()
self.instances = utility:Combine(self.instances, {list_title,

list_frame, list_frame_outline, list_frame_scrollbar, unpack(list.opinst)})
table.insert(self.things.lists, list)
return list
end
section.instances = {section_frame, section_inline, section_outline,

section_title, section_title_bold, section_accent, section_accent2}
if not section.rna then

table.insert(self.sections, section)
table.insert(self.sides[side == "left" and 1 or 2], section)
end
return section
end
if self.sshit == nil then

self:SelectTab(name)
end
Enum.UserInputType.MouseButton1 and utility:MouseOverDrawing(tab_frame) then
self:SelectTab(name)
end
end)
return tab
end
function window.FakeRealMouseFuckingImAloneGoingToKillMyselfWithKnife(self,
section)
if self.shit.dropdown ~= nil and #self.shit.dropdown.instances > 1 then
return utility:MouseOverDrawing(self.shit.dropdown.instances[1])
elseif self.shit.keybind ~= nil and #self.shit.keybind.minst > 1 then
return utility:MouseOverDrawing(self.shit.keybind.minst[1])
elseif self.shit.colorpicker ~= nil and #self.shit.colorpicker.instances >
1 then
return utility:MouseOverDrawing(self.shit.colorpicker.instances[1])
end
if not table.find(window.rna, section) then

local on = false
for i, v in pairs(window.rna) do
if on then break end
on = utility:MouseOverDrawing(v.instances[1])
end
return on
end
return false
end
function window.NewTheme(self, theme)

self.theme = theme
for i, _ in pairs(self.theme) do
for _, obj in pairs(library.groups[i]) do
obj.Color = self.theme[i]
end
end
for _, tab in pairs(self.tabs) do

tab:Update()
end
end
function window.SelectTab(self, name)
for i, v in pairs(self.tabs) do
if v.instances[3].Text == name then
v:Show()
self.sshit = v
else
v:Hide()
end
end
for _, v in pairs(self.connections["tab"] or {}) do

v(name)
end
end
function window.Resize(self, size)

main_frame.Size = size
main_frame_outline.Size = main_frame.Size + v2new(2, 2)
main_frame_accent.Size = main_frame.Size + v2new(4, 4)
pretab_frame.Size = size - v2new(12, 26)

pretab_frame_inline.Size = pretab_frame.Size + v2new(2, 2)
pretab_frame_outline.Size = pretab_frame.Size + v2new(4, 4)
tabs_frame.Size = size - v2new(24, 55)

tabs_frame_outline.Size = tabs_frame.Size + v2new(2, 2)
v:Update()
end
end
function
window.HideUselessDumbassFuckingShitStopPastingMyCodePleaseYouAreSkidAndImGayILikeB
7(self)
if self.shit.dropdown then
self.shit.dropdown:Close()
elseif self.shit.textbox then
self.shit.textbox:Stop()
elseif self.shit.keybind then
self.shit.keybind:Close()
elseif self.shit.colorpicker then
self.shit.colorpicker:Close()
end
end
function window.GetFakeRealNoobConfigFunctionDontUseMe(self)
local new_table = {}
for i, v in pairs(library.pointers) do
new_table[i] = v:Get()
end
new_table["animation_saved"] = self.saved_settings
return game:GetService("HttpService"):JSONEncode(new_table)
end
function
window.BestFunctionToKillMyselfFurryGayPornFemboyDildoMasterAloneWolfMode(self,
IHATEMYSELFFUCKINGIWANTTODIEIMUSELESSINTHISLIFENOBODYLIKESME)
for USELESSNAMEFORNONAMERIHATEMYSELF,
SHITTYVALUEFORNOBODYCAUSEIMALONEIMSODUMBFUCKINGUSELESS in
pairs(IHATEMYSELFFUCKINGIWANTTODIEIMUSELESSINTHISLIFENOBODYLIKESME) do
if library.pointers[USELESSNAMEFORNONAMERIHATEMYSELF] then
library.pointers[USELESSNAMEFORNONAMERIHATEMYSELF]:Set(SHITTYVALUEFORNOBODYCAUSEIMA
LONEIMSODUMBFUCKINGUSELESS)
end
end
self.saved_settings =
IHATEMYSELFFUCKINGIWANTTODIEIMUSELESSINTHISLIFENOBODYLIKESME["animation_saved"] or
{}
end
function
window.SetSecretFunctionNameNotWindowNameClickGrabifyPNEK8UPleaseBotlagArgyyyHaxx(s
elf, newsecretpropertyname)
main_frame_title.Text = newsecretpropertyname
end
function window.Fade(self)
if self.fading then return end
for i, v in pairs(self.connections["fade"] or {}) do

v(not main_frame.Visible)
end
if main_frame.Visible then
self.fading = true
if self.tooltip then
self.tooltip:SetPosition(v2new(-1000, -1000))
end
for i, v in pairs(library.drawings[1]) do
v[1].Lerp({Transparency = 0}, 0.2)
task.delay(0.2, function()
v[1].Visible = false
self.fading = false
end)
end
uis.MouseIconEnabled = true
else
self.fading = true
for i, v in pairs(library.drawings[1]) do
v[1].Visible = true
v[1].Transparency = 0
v[1].Lerp({Transparency = v[2]}, 0.2)

end
task.delay(0.2, function()
self.fading = false
end)
local from = tick()
while tick()-from < 0.2 and task.wait() do

self:SelectTab(self.sshit.name)
end
uis.MouseIconEnabled = false
end
v:Update()
end
self:HideUselessDumbassFuckingShitStopPastingMyCodePleaseYouAreSkidAndImGayILikeBig
BlackManOkNoProblemThisIsASexcretFuncteiotieitns4epoivi2n45obvi6j45bv74gvho4hgv487(
)
end
function window.Notifications(self)
local notiflist = {ntifs = {}, interval = 7}
function notiflist.new(self, info)
info = info or {}
local text = info.text or "notification"

local dur = info.dur or info.duration or 3
local show_dur_bar = info.show_dur_bar or info.sdb or true
local pulse = info.pulse or false
local pulse_color = info.pulsecolor or info.pulse_color or info.pc or
{c3rgb(0, 0, 0), c3rgb(194, 164, 16)}
local text_highlight = info.th or info.text_highlight or {}
local ntif = {text = text, dur = dur, pulse = pulse, pc = pulse_color,

pm = 1, ptick = 0, create_tick = tick(), sdb = show_dur_bar, instances = {}}
local ntif_frame = utility:Draw("Square", nil, {

Group = "lcont",
Size = v2new(7 + utility:GetPlexSize(text), 4 + (#text:split("\
n")*13)),
Position = v2new(-utility:GetPlexSize(text), 0)
}, true)
if #text:split("\n") > 1 then

local max = 0
for i, v in pairs(text:split("\n")) do
if utility:GetPlexSize(v) > max then
max = utility:GetPlexSize(v)
end
end
ntif_frame.Size = v2new(5 + max, ntif_frame.Size.Y)

ntif_frame.Position = v2new(-max, 0)
end
local ntif_frame_outline = utility:Draw("Square", v2new(-1, -1), {

Group = "outline",
Size = ntif_frame.Size + v2new(2, 2),
Filled = false,
Parent = ntif_frame
}, true)
local ntif_text = utility:Draw("Text", v2new(5, 2), {

Color = c3rgb(255, 255, 255),
Outline = true,
Size = 13,
Font = 2,
Text = ntif.text,
Parent = ntif_frame
}, true)
local ntif_dur_line = utility:Draw("Square", v2new(0,

ntif_frame.Size.Y), {
Group = "accent",
Size = v2new(ntif_frame.Size.X / 5, 1),
Visible = ntif.sdb,
Parent = ntif_frame
}, true)
local ntif_accent = utility:Draw("Square", v2zero, {

Size = v2new(2, ntif_frame.Size.Y),
Color = not ntif.pulse and window.theme.accent or ntif.pc[1],
Group = "accent",
Parent = ntif_frame
}, true)
local highligted = {}
for _, v in pairs(text_highlight) do
local s, e = ntif.text:find(v[1])
if s and e then
local ntif_high = utility:Draw("Text", v2new((s-1)*7, 0), {
Color = v[2],
Outline = true,
Size = 13,
Font = 2,
Text = ntif.text:sub(s, e),
Parent = ntif_text
}, true)
table.insert(highligted, ntif_high)
end
end
ntif.lupapupa = utility:Connect(rs.Heartbeat, function()

if ntif.sdb then
ntif_dur_line.SetOffset(v2new(((tick()-ntif.create_tick) /
ntif.dur) * (ntif_frame.Size.X * 0.8), ntif_frame.Size.Y))
end
if ntif.pulse then
if tick()-ntif.ptick > 0.5 then
ntif.ptick = tick()
if ntif.pm == 1 then
ntif.pm = 2
ntif_accent.Lerp({Color = ntif.pc[ntif.pm]}, 0.5)

else
ntif.pm = 1
ntif_accent.Lerp({Color = ntif.pc[ntif.pm]}, 0.5)

end
end
end
if tick()-ntif.create_tick > ntif.dur - 0.2 and not ntif.did_set

then
ntif.did_set = true
ntif:idontlikemylifesucidepleasesomebodykillme()
end
end)
function ntif.idontlikemylifesucidepleasesomebodykillme(self)
v.Lerp({Transparency = 0}, 0.2)
end
task.wait(0.2)
v.Remove()
end
if self.lupapupa then
self.lupapupa:Disconnect()
end
table.remove(notiflist.ntifs, table.find(notiflist.ntifs, ntif))
notiflist:reposition()
end
ntif.instances = {ntif_frame, ntif_frame_outline, ntif_text,

ntif_dur_line, ntif_accent, unpack(highligted)}
table.insert(self.ntifs, ntif)
self:reposition()
end
function notiflist.reposition(self)
local position_to_go = 60 + self.interval
for i, v in pairs(self.ntifs) do
local position = v2new(19, position_to_go)
local lerp_table = {Position = position}
if v.instances[1].Position.X < 0 then

v.instances[1].Position = position + v2new(-4, 7)
for i, v in pairs(v.instances) do
v.Transparency = 0
if i == 1 then
lerp_table.Transparency = 1
else
v.Lerp({Transparency = 1}, 0.1, false)
end
end
end
v.instances[1].Lerp(lerp_table, 0.1, false)
position_to_go = position_to_go + v.instances[1].Size.Y +

self.interval
end
end
self.ntiflist = notiflist
end
function window.Keybinds(self)
local kblist = {visible = false, instances = {}}
local kblist_frame = utility:Draw("Square", v2zero, {

Group = "lcont",
Size = v2new()
}, true)
local kblist_outline = utility:Draw("Square", v2new(-1, -1), {

Group = "outline",
Size = kblist_frame.Size + v2new(2, 2),
Filled = false,
Parent = kblist_frame
}, true)
local kblist_accent = utility:Draw("Square", v2zero, {

Size = v2new(kblist_frame.Size.X, 1),
Group = "accent",
}, true)
local kblist_title = utility:Draw("Text", v2new(3, 3), {

Color = c3rgb(255, 255, 255),
Outline = true,
Size = 13,
Font = 2,
Text = "keybinds",
}, true)
local kblist_value = utility:Draw("Text", v2new(3, 17), {

Color = c3rgb(255, 255, 255),
Outline = true,
Size = 13,
Font = 2,
Text = "",
}, true)
function kblist.Update(self)
local kbds_string = ""
local max_len = 56
for i, v in pairs(window.kbds) do
local keybind = library.pointers[v]
local string_add = ("[%s] %s: %s\

n"):format(keybind.instances[5].Text, keybind.sname, keybind.name)
if utility:GetPlexSize(string_add) > max_len then

max_len = utility:GetPlexSize(string_add)
end
kbds_string = kbds_string .. string_add

end
kblist_frame.Size = v2new(6 + max_len, 20 + ((#kbds_string:split("\n")-

1)*13))
kblist_outline.Size = kblist_frame.Size + v2new(2, 2)
kblist_accent.Size = v2new(kblist_frame.Size.X, 1)
kblist_value.Text = kbds_string
end
function kblist.AdjustFuckingUselessShitNamedPositionIWantToDie(self, pos)

kblist_frame.Position = pos
end
function
kblist.ShowHideFromMyLifePleaseSomebodyKillMeIDontWantToBeAliveRightNowImUselessInM
yLife(self, visible)
v.Visible = visible
end
end
kblist.instances = {kblist_frame, kblist_outline, kblist_accent,

kblist_title, kblist_value}
kblist:Update()
kblist:AdjustFuckingUselessShitNamedPositionIWantToDie(v2new(20,
math.floor(utility:ScreenSize().Y/2)))
kblist:ShowHideFromMyLifePleaseSomebodyKillMeIDontWantToBeAliveRightNowImUselessInM
yLife(false)
self.kblist = kblist
end
function window.Watermark(self)
local watermark = {text = "worsst fucking ui without doxxs", visible =

false, instances = {}}
local watermark_frame = utility:Draw("Square", v2zero, {

Group = "lcont",
Size = v2new(0, 20),
}, true)
local watermark_inline = utility:Draw("Square", v2new(-1, -1), {

Group = "dcont",
Size = watermark_frame.Size + v2new(2, 2),
Filled = false,
Parent = watermark_frame
}, true)
local watermark_outline = utility:Draw("Square", v2new(-2, -2), {

Group = "outline",
Size = watermark_frame.Size + v2new(4, 4),
Filled = false,
}, true)
local watermark_accent = utility:Draw("Square", v2new(), {

Size = v2new(watermark_frame.Size.X, 1),
Group = "accent",
}, true)
local watermark_gradient = utility:Draw("Image", v2new(0, 1), {

Size = watermark_frame.Size - v2new(0, 1),
}, true)
local watermark_title = utility:Draw("Text", v2new(3, 4), {

Color = c3rgb(255, 255, 255),
Outline = true,
Size = 13,
Font = 2,
Text = watermark.text,
}, true)
utility:Image(watermark_gradient, "https://s3.us-east-1.wasabisys.com/e-
zimagehosting/7832f20c-64f3-46ac-bbdc-24b47117be2a/q7k8an2m.png")
watermark.instances = {watermark_frame, watermark_inline,

watermark_outline, watermark_accent, watermark_gradient, watermark_title}
function watermark.Update(self)
local bounds = utility:GetPlexSize(self.text)
watermark_frame.Size = v2new(6 + bounds, 20)

watermark_inline.Size = watermark_frame.Size + v2new(2, 2)
watermark_outline.Size = watermark_inline.Size + v2new(2, 2)
watermark_accent.Size = v2new(watermark_frame.Size.X, 1)
watermark_gradient.Size = watermark_frame.Size - v2new(0, 1)
watermark_frame.Position = v2new(20, 40)

end
function watermark.SetVisible(self, value)

self.visible = value
v.Visible = self.visible
end
end
function watermark.SetText(self, value)

self.text = value
end
watermark:Update()
watermark_title.Text = watermark.text
end)
watermark:SetVisible(false)
self.watermark = watermark
end
function window.Tooltip(self)
local tooltip = {instances = {}}
local tt_frame = utility:Draw("Square", nil, {

Color = self.theme.dcont,
Group = "dcont",
Size = v2new(0, 17)
})
local tt_frame_outline = utility:Draw("Square", v2new(-1, -1), {

Color = self.theme.outline,
Group = "outline",
Size = tt_frame.Size + v2new(2, 2),
Filled = false,
Parent = tt_frame
})
local tt_accent = utility:Draw("Square", v2zero, {

Color = self.theme.accent,
Size = v2new(2, tt_frame.Size.Y),
Group = "accent",
Parent = tt_frame
})
local tt_text = utility:Draw("Text", v2new(5, 2), {

Color = c3rgb(255, 255, 255),
Outline = true,
Size = 13,
Font = 2,
Text = "",
Parent = tt_frame
})
tooltip.instances = {tt_frame, tt_frame_outline, tt_accent, tt_text}
function tooltip.SetText(self, text)

v.Visible = true
end
tt_text.Text = text
tt_frame.Size = v2new(7 + utility:GetPlexSize(text), 4 +

(#text:split("\n")*13))
if #text:split("\n") > 1 then

local max = 0
for i, v in pairs(text:split("\n")) do
if utility:GetPlexSize(v) > max then
max = utility:GetPlexSize(v)
end
end
tt_frame.Size = v2new(5 + max, tt_frame.Size.Y)

end
tt_frame_outline.Size = tt_frame.Size + v2new(2, 2)
tt_accent.Size = v2new(2, tt_frame.Size.Y)
end
function tooltip.SetPosition(self, pos)

tt_frame.Position = pos
end
tooltip:SetPosition(v2new(-1000, -1000))
self.tooltip = tooltip
end
function window.Cursor(self)
local cursor = {position = v2zero, instances = {}}
local triangle = utility:Draw("Triangle", v2zero, {

Group = "accent",
Filled = true,
Thickness = 0,
ZIndex = 65
})
local triangle_outline = utility:Draw("Triangle", v2zero, {

Group = "outline",
Filled = false,
Thickness = 1,
ZIndex = 66
})
function cursor.Update(self)
triangle.PointA = self.position
triangle.PointB = self.position + v2new(10, 4)
triangle.PointC = self.position + v2new(4, 10)
triangle_outline.PointA = triangle.PointA
triangle_outline.PointB = triangle.PointB
triangle_outline.PointC = triangle.PointC
end
function cursor.Set(self, value)

self.position = value
self:Update()
end
if window.frame.Visible then
cursor:Set(uis:GetMouseLocation())
end
end)
cursor.instances = {triangle, triangle_outline}
window.cursor = cursor
end
function window.Init(self)
for _, tab in pairs(self.tabs) do

tab:Update()
end
if #self.tabs > 0 then

self.saved_settings = {}
local slider_section = self.tabs[1]:Section({name = "Animation", rna =

true})
local anim_enabled = slider_section:Toggle({name = "Enabled", pointer =
""})
local anim_speed = slider_section:Slider({name = "Speed", min = 0.1,
def = 1, max = 5, dec = 10, pointer = ""})
local anim_min = slider_section:Slider({name = "Minimum value", min =
1, max = 2, pointer = ""})
local anim_max = slider_section:Slider({name = "Maximum value", min =
1, max = 2, pointer = ""})
slider_section:Update()
slider_section:SetPositionIHateMyselfAndIWannaDieOk(v2new(-1000, -
1000))
local slider_flag = nil
if self.frame.Visible and not
window:FakeRealMouseFuckingImAloneGoingToKillMyselfWithKnife(slider_section) then
local slider_visible = false
for _, section in pairs(window.sshit.sections) do

if slider_visible then break end
for _, slider in pairs(section.things.sliders) do
if slider_visible then break end
local section_frame = section.instances[1]

local slider_title = slider.instances[1]
if
slider_title.GetOffset().Y), section_frame.Position + v2new(section_frame.Size.X,
slider_title.GetOffset().Y + 29)}) then
slider_visible = true
slider_section:SetPositionIHateMyselfAndIWannaDieOk(slider_title.Position +
v2new(2, 2))
anim_min.min = slider.min
anim_min.max = slider.max
anim_min.dec = slider.dec
anim_max.min = slider.min
anim_max.max = slider.max
anim_max.dec = slider.dec
slider_flag = slider.pointer
if self.saved_settings[slider.pointer] then
local settings =
self.saved_settings[slider.pointer]
anim_enabled:Set(settings.enabled)
anim_min:Set(settings.min)
anim_max:Set(settings.max)
anim_speed:Set(settings.speed)
else
anim_enabled:Set(false)
anim_min:Set(slider.min)
anim_max:Set(slider.max)
anim_speed:Set(1)
self.saved_settings[slider.pointer] = {
enabled = false,
min = slider.min,
max = slider.max,
speed = 1,
dec = slider.dec,
random_angle_offset = math.random(-720,
720)
}
end
end
end
end
if not slider_visible then
slider_section:SetPositionIHateMyselfAndIWannaDieOk(v2new(-1000, -1000))
slider_flag = nil
end
elseif input.UserInputType == Enum.UserInputType.MouseButton1
then
if not
utility:MouseOverDrawing(slider_section.instances[1]) then
slider_section:SetPositionIHateMyselfAndIWannaDieOk(v2new(-1000, -1000))
slider_flag = nil
end
end
else
slider_section:SetPositionIHateMyselfAndIWannaDieOk(v2new(-
1000, -1000))
slider_flag = nil
end
end)
utility:Connect(rs.Heartbeat, function()
if slider_flag ~= nil then
self.saved_settings[slider_flag] = {
enabled = anim_enabled:Get(),
min = anim_min:Get(),
max = anim_max:Get(),
speed = anim_speed:Get(),
dec = library.pointers[slider_flag].dec,
random_angle_offset =
self.saved_settings[slider_flag].random_angle_offset
}
end
for i, v in pairs(self.saved_settings) do
if v.enabled then
local sin_tick = 1 + math.sin(math.rad((tick()*50*v.speed))
+ math.rad(v.random_angle_offset))
if tostring(sin_tick):sub(1, 4) == "1.99" then

sin_tick = 2
end
library.pointers[i]:Set(math.clamp(math.floor((v.min +
(((v.max - v.min)/2) * sin_tick)) * v.dec) / v.dec, v.min, v.max))
end
end
end)
end
self:Watermark()
self:Notifications()
self:Tooltip()
self:Keybinds()
self:Cursor()
self:Fade()
task.wait(0.2)
self:SelectTab(self.sshit.name)
library.loaded = true
function self.Unload(self)
for i, v in pairs(utility:Combine(library.drawings[1],
library.drawings[2])) do
v[1]:Remove()
end
for i, v in pairs(library.connections) do
v:Disconnect()
end
for i, v in pairs(self.connections["unload"] or {}) do

v()
end
library.loaded = false
end
end
function window.Connect(self, info)

info = info or {}
local connection = info.con or "tab"

if not self.connections[connection] then

self.connections[connection] = {}
end
table.insert(self.connections[connection], callback)
end
return window
end
local Workspace = game:GetService("Workspace")

local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local LocalPlayer = Players.LocalPlayer
local LocalCharacter = LocalPlayer.Character
local LocalHumanoid = LocalCharacter.Humanoid
local LocalRootPart = LocalCharacter.HumanoidRootPart
function ChangeHumanoidStateType(State)
LocalHumanoid:ChangeState(State)
end
function SetPosition(Object, Positioning)

Object.Position = Positioning
end
function SetCFrame(Object, CFrameValue)

Object.CFrame = CFrameValue
end
function tominutes(custominutes)
local mathscal = custominutes*60
return mathscal
end
function GetPropertyValue(Property, PropertyType)

if PropertyType == Normal then
local PropertyValue = Property
elseif PropertyType == String then
local PropertyValue = tostring(Property)
else
local PropertyValue = Property
end
return PropertyValue
end
function GetPlayers()
getgenv().PlayersTable = {}
for i,v in pairs(Players:GetPlayers()) do

table.insert(getgenv().PlayersTable, v)
end
return getgenv().PlayersTable
end
function CurrentPlayers()
local CurrentTPlayers = {}
for i,v in pairs(GetPlayers()) do
CurrentTPlayers = {i}
end
return CurrentTPlayers
end
function GetCustomChild(Parent, Class)

local TheParentService = game:GetService(tostring(Parent))
for i,v in pairs(TheParentService:GetChildren()) do

print(v.ClassName)
print(Class)
if v.ClassName == tostring(Class) then
print(v)
local CustomChild = v.Name
end
end
return CustomChild
end
function InsertMultiProperties(Table, Properties)

local Properties = Properties or {}
for i,v in pairs(Properties) do

table.insert(Table, v)
end
end
function GetAllBodyParts(v)
local Parts = {}
if v.Character.Humanoid.RigType == Enum.HumanoidRigType.R6 then

InsertMultiProperties(Parts, {"Head", "Torso", "Right Arm", "Left Arm",
"Left Leg", "Right Leg", "HumanoidRootPart"})
elseif v.Character.Humanoid.RigType == Enum.HumanoidRigType.R15 then
InsertMultiProperties(Parts, {"Head", "UpperTorso", "HumanoidRootPart",
"LowerTorso", "LeftLowerArm", "LeftUpperArm", "LeftHand", "RightLowerArm",
"RightUpperArm", "RightHand", "LeftLowerLeg", "LeftUpperLeg", "LeftFoot",
"RightUpperLeg", "RightLowerLeg", "RightFoot"})
end
return Parts
end
local MainTable = {
ESPEnabled = false,
ESPTeamCheck = false,
Box = false,
BoxColor = Color3.fromRGB(0,255,0),
HealthBar = false,
HealthBarColor = Color3.fromRGB(0,255,0),
HealthText = false,
HealthTextColor = Color3.fromRGB(0,255,0),
Name = false,
NameColor = Color3.fromRGB(0,255,0),
DistanceText = false,
DistanceColor = Color3.fromRGB(0,255,0),
DistanceCheck = false,
DistanceCheckAmount = 1,
Skeleton = false,
SkeletonColor = Color3.fromRGB(0,255,0),
TriggerBotEnabled = false,
Delay = 0,
TriggerBotTeamCheck = false,
AimEnabled = false,
Hitbox = "Head",
WallCheck = false,
ShowFov = false,
Radius = 1,
FovColor = Color3.fromRGB(0,255,0),
HorizontalSmoothness = 1,
VerticalSmoothness = 1,
WallCheckOrigin = "Camera",
Prediction = false,
PredictionAmount = 0,
BackTracing = false,
AimTeamCheck = false,
SpeedMultiplier = false,
Speed = 0,
AspectRatio = false,
Ratio = 0,
Chams = false,
ChamsColor = Color3.fromRGB(0,255,0),
Glow = false,
GlowColor = Color3.fromRGB(0,255,0),
}
local Window = library:Window({name = "pintohaxx from walmart"})
local AimbotTab = Window:Tab({name = "Aimbot"})
local VisualsTab = Window:Tab({name = "Visuals"})
local MiscTab = Window:Tab({name = "Misc"})
local SettingsTab = Window:Tab({name = "Settings"})
local AimAssistSection = AimbotTab:Section({name = "Aim Assist", side = "left"})
local AimbotToggle = AimAssistSection:Toggle({name = "Enabled", def = false,

callback = function(v)
MainTable.AimEnabled = v
end})
local HitboxDropdown = AimAssistSection:Dropdown({name = "Hitbox", options =

{"Head", "Chest", "Stomach"}, def = "Head", mutli = false, scrollable = false, vis
= 3, min = 3, callback = function(y)
if y == "Head" then
MainTable.Hitbox = "Head"
elseif y == "Chest" then
MainTable.Hitbox = "UpperTorso"
elseif y == "Stomach" then
MainTable.Hitbox = "HumanoidRootPart"
end
end})
AimAssistSection:Toggle({name = "Team Check", def = false, callback = function(v)

MainTable.AimTeamCheck = v
end})
AimAssistSection:Toggle({name = "Visible Check", def = false, callback =

function(v)
MainTable.WallCheck = v
end})
AimAssistSection:Dropdown({name = "Origin", options = {"Camera", "Player"}, def =

"Camera", mutli = false, scrollable = false, vis = 2, min = 2, callback =
function(y)
MainTable.WallCheckOrigin = y
end})
AimAssistSection:Slider({name = "Horizontal Smoothing", min = 1, max = 100, dec =

1, suf = "%", def = 1, callback = function(v)
MainTable.HorizontalSmoothness = v
end})
AimAssistSection:Slider({name = "Vertical Smoothing", min = 1, max = 100, dec = 1,

suf = "%", def = 1, callback = function(v)
MainTable.VerticalSmoothness = v
end})
local VisualsASection = AimbotTab:Section({name = "Visuals", side = "right"})
VisualsASection:Toggle({name = "Draw FOV", def = false, callback = function(v)

MainTable.ShowFov = v
end}):Colorpicker({name = "Bruh", def = Color3.fromRGB(0,255,0), callback =
function(v)
MainTable.FovColor = v
end})
VisualsASection:Slider({name = "Radius", min = 1, max = 180, dec = 1, suf = "px",

def = 1, callback = function(v)
MainTable.Radius = v*3
end})
local TracingSection = AimbotTab:Section({name = "Tracing Configuration", side =

"right"})
TracingSection:Toggle({name = "Player Prediction", def = false, callback =

function(v)
MainTable.Prediction = v
end})
TracingSection:Slider({name = "Prediction Amount", min = 1, max = 100, dec = 1, def

= 1, callback = function(v)
MainTable.PredictionAmount = v/500
end})
TracingSection:Toggle({name = "Back Tracing", def = false, callback = function(v)

MainTable.BackTracing = v
end})
local TriggerBotSection = AimbotTab:Section({name = "Trigger bot", side = "left"})
TriggerBotSection:Toggle({name = "Enabled", def = false, callback = function(v)

MainTable.TriggerBotEnabled = v
end})
TriggerBotSection:Toggle({name = "Team Check", def = false, callback = function(v)

MainTable.TriggerBotTeamCheck = v
end})
TriggerBotSection:Slider({name = "Delay", min = 0, max = 5000, dec = 1, suf = "ms",

def = 0, callback = function(v)
MainTable.Delay = v/1000
end})
function TriggerTeamCheck(v)
if MainTable.TriggerBotTeamCheck then
if v.TeamColor ~= game.Players.LocalPlayer.TeamColor then
return true
else
return false
end
else
return true
end
end
local Players = game:GetService("Players")

local lp = Players.LocalPlayer or
Players:GetPropertyChangedSignal("LocalPlayer"):Wait() and Players.LocalPlayer
local mouse = lp:GetMouse()
local function gettarget(instance)

for i,v in next, Players:GetPlayers() do
if TriggerTeamCheck(v) and MainTable.TriggerBotEnabled then
if v.Character and (instance == v.Character or
instance:IsDescendantOf(v.Character)) then
return true
end
end
end
end
local con = game:GetService("RunService").Heartbeat:Connect(function()

if gettarget(mouse.Target) then
mouse1press()
task.wait()
mouse1release()
end
end)
local CC = game.Workspace.CurrentCamera
local Mouse = game.Players.LocalPlayer:GetMouse()
local Fov = Drawing.new("Circle")

function UpdateFOV()
if MainTable.AimEnabled then
Fov.Visible = MainTable.ShowFov
else
Fov.Visible = false
end
Fov.Radius = MainTable.Radius
Fov.Thickness = 1
Fov.Color = MainTable.FovColor
Fov.Position = Vector2.new(Mouse.X, Mouse.Y+35)
end
function WallCheck(part, ignore)

if MainTable.WallCheck then
if MainTable.WallCheckOrigin == "Camera" then
Origin = CC.CFrame.Position
elseif MainTable.WallCheckOrigin == "Player" then
Origin = game.Players.LocalPlayer.Character.HumanoidRootPart.Position
end
CheckRay = Ray.new(Origin, part- Origin)
Hit = workspace:FindPartOnRayWithIgnoreList(CheckRay, ignore)
return Hit == nil
else
return true
end
end
function GetClosestPlayerToMouse()
local Target = nil
Closest = math.huge
for i,v in pairs(game.Players:GetPlayers()) do
pcall(function()
if v.Character and v.Character.Humanoid and v.Character.Humanoid.Health ~=
0 and v.Character.HumanoidRootPart and
WallCheck(v.Character.HumanoidRootPart.Position,
{game.Players.LocalPlayer.Character,v.Character}) and v ~= game.Players.LocalPlayer
then
local pos,onscreen =
CC:WorldToScreenPoint(v.Character[MainTable.Hitbox].Position)
if onscreen then
local distance = (Vector2.new(pos.X, pos.Y) - Vector2.new(Mouse.X,
Mouse.Y+35)).magnitude
if distance < Fov.Radius and distance < Closest then
Closest = distance
Target = v
end
end
end
end)
end
return Target
end
function AimAtTarget(Hitbox)
WTSP = CC:WorldToScreenPoint(Hitbox)
mousemoverel((WTSP.X - Mouse.X)/MainTable.HorizontalSmoothness, (WTSP.Y -
Mouse.Y)/MainTable.VerticalSmoothness)
end
game:GetService("RunService").RenderStepped:Connect(function()
UpdateFOV()
if MainTable.AimEnabled then
local MainTarget = GetClosestPlayerToMouse()
if MainTarget then
if MainTable.AimTeamCheck then
if MainTarget.TeamColor ~= game.Players.LocalPlayer.TeamColor then
if MainTable.Prediction then
if MainTable.BackTracing then
AimAtTarget(MainTarget.Character[MainTable.Hitbox].Position-
MainTarget.Character[MainTable.Hitbox].Velocity * MainTable.PredictionAmount)
else
AimAtTarget(MainTarget.Character[MainTable.Hitbox].Position+MainTarget.Character[Ma
inTable.Hitbox].Velocity * MainTable.PredictionAmount)
end
else
AimAtTarget(MainTarget.Character[MainTable.Hitbox].Position)
end
end
else
if MainTable.Prediction then
if MainTable.BackTracing then
AimAtTarget(MainTarget.Character[MainTable.Hitbox].Position-
MainTarget.Character[MainTable.Hitbox].Velocity * MainTable.PredictionAmount)
else
AimAtTarget(MainTarget.Character[MainTable.Hitbox].Position+MainTarget.Character[Ma
inTable.Hitbox].Velocity * MainTable.PredictionAmount)
end
else
AimAtTarget(MainTarget.Character[MainTable.Hitbox].Position)
end
end
end
else
MainTarget = nil
end
end)
local PlayerESPSection = VisualsTab:Section({name = "Player ESP", side = "left"})
local ESPToggle = PlayerESPSection:Toggle({name = "Enabled", def = false, callback

= function(v)
MainTable.ESPEnabled = v
end})
local SkeletonToggle = PlayerESPSection:Toggle({name = "Skeleton", def = false,

MainTable.Skeleton = v
function(v)
MainTable.SkeletonColor = v
end})
local BoxToggle = PlayerESPSection:Toggle({name = "Box", def = false, callback =

function(v)
MainTable.Box = v
function(v)
MainTable.BoxColor = v
end})
PlayerESPSection:Toggle({name = "Team Check", def = false, callback = function(v)

MainTable.ESPTeamCheck = v
end})
local HealthBarToggle = PlayerESPSection:Toggle({name = "Health Bar", def = false,

MainTable.HealthBar = v
function(v)
MainTable.HealthBarColor = v
end})
local HealthTextToggle = PlayerESPSection:Toggle({name = "Health Text", def =

false, callback = function(v)
MainTable.HealthText = v
function(v)
MainTable.HealthTextColor = v
end})
local NameTextToggle = PlayerESPSection:Toggle({name = "Name", def = false,

MainTable.Name = v
function(v)
MainTable.NameColor = v
end})
local DistanceTextToggle = PlayerESPSection:Toggle({name = "Distance", def = false,

MainTable.DistanceText = v
function(v)
MainTable.DistanceColor = v
end})
PlayerESPSection:Toggle({name = "Distance Check", def = false, callback =

function(v)
MainTable.DistanceCheck = v
end})
PlayerESPSection:Slider({name = "Distance", min = 1, max = 2500, dec = 1, suf =

"m", def = 1, callback = function(v)
MainTable.DistanceCheckAmount = v
end})
function TeamCheck(v)
if MainTable.ESPTeamCheck then
if v.TeamColor ~= game.Players.LocalPlayer.TeamColor then
return true
else
return false
end
else
return true
end
end
local CC = game.Workspace.CurrentCamera
local Camera = game.Workspace.Camera
local Draw = Drawing.new
local Vec2 = Vector2.new
function PlayerESP(Player)
local BoxOutline = Drawing.new("Square")
BoxOutline.Visible = false
BoxOutline.Thickness = 3
BoxOutline.Filled = false
BoxOutline.Color = Color3.fromRGB(0,0,0)
local Box = Drawing.new("Square")

Box.Visible = false
Box.Thickness = 1
Box.Filled = false
Box.Color = MainTable.BoxColor
local HealthBarOutline = Drawing.new("Square")

HealthBarOutline.Visible = false
HealthBarOutline.Thickness = 2
HealthBarOutline.Filled = false
HealthBarOutline.Color = Color3.fromRGB(0,0,0)
local HealthBar = Drawing.new("Square")

HealthBar.Visible = false
HealthBar.Thickness = 1
HealthBar.Filled = true
HealthBar.Color = MainTable.HealthBarColor
local HealthText = Drawing.new("Text")

HealthText.Text = "N/A"
HealthText.Size = 13
HealthText.Color = MainTable.HealthTextColor
HealthText.Visible = false
HealthText.Outline = true
HealthText.OutlineColor = Color3.fromRGB(0,0,0)
HealthText.Font = 2
local NameText = Drawing.new("Text")

NameText.Text = "N/A"
NameText.Size = 13
NameText.Color = MainTable.NameColor
NameText.Visible = false
NameText.Outline = true
NameText.OutlineColor = Color3.fromRGB(0,0,0)
NameText.Font = 2
local DistanceText = Drawing.new("Text")

DistanceText.Text = "N/A"
DistanceText.Size = 13
DistanceText.Color = MainTable.DistanceColor
DistanceText.Visible = false
DistanceText.Outline = true
DistanceText.OutlineColor = Color3.fromRGB(0,0,0)
DistanceText.Font = 2
local Head_Torso_Skeleton = Draw("Line")

Head_Torso_Skeleton.Thickness = 1
Head_Torso_Skeleton.Visible = false
Head_Torso_Skeleton.Transparency = 1
Head_Torso_Skeleton.ZIndex = 1
Head_Torso_Skeleton.Color = MainTable.SkeletonColor
local Torso_LowerTorso_Skeleton = Draw("Line")

Torso_LowerTorso_Skeleton.Thickness = 1
Torso_LowerTorso_Skeleton.Visible = false
Torso_LowerTorso_Skeleton.Transparency = 1
Torso_LowerTorso_Skeleton.ZIndex = 1
Torso_LowerTorso_Skeleton.Color = MainTable.SkeletonColor
local Torso_RightUpperArm_Skeleton = Draw("Line")

Torso_RightUpperArm_Skeleton.Thickness = 1
Torso_RightUpperArm_Skeleton.Visible = false
Torso_RightUpperArm_Skeleton.Transparency = 1
Torso_RightUpperArm_Skeleton.ZIndex = 1
Torso_RightUpperArm_Skeleton.Color = MainTable.SkeletonColor
local Torso_RightLowerArm_Skeleton = Draw("Line")

Torso_RightLowerArm_Skeleton.Thickness = 1
Torso_RightLowerArm_Skeleton.Visible = false
Torso_RightLowerArm_Skeleton.Transparency = 1
Torso_RightLowerArm_Skeleton.ZIndex = 1
Torso_RightLowerArm_Skeleton.Color = MainTable.SkeletonColor
local Torso_RightHand_Skeleton = Draw("Line")

Torso_RightHand_Skeleton.Thickness = 1
Torso_RightHand_Skeleton.Visible = false
Torso_RightHand_Skeleton.Transparency = 1
Torso_RightHand_Skeleton.ZIndex = 1
Torso_RightHand_Skeleton.Color = MainTable.SkeletonColor
local Torso_LeftUpperArm_Skeleton = Draw("Line")

Torso_LeftUpperArm_Skeleton.Thickness = 1
Torso_LeftUpperArm_Skeleton.Visible = false
Torso_LeftUpperArm_Skeleton.Transparency = 1
Torso_LeftUpperArm_Skeleton.ZIndex = 1
Torso_LeftUpperArm_Skeleton.Color = MainTable.SkeletonColor
local Torso_LeftLowerArm_Skeleton = Draw("Line")

Torso_LeftLowerArm_Skeleton.Thickness = 1
Torso_LeftLowerArm_Skeleton.Visible = false
Torso_LeftLowerArm_Skeleton.Transparency = 1
Torso_LeftLowerArm_Skeleton.ZIndex = 1
Torso_LeftLowerArm_Skeleton.Color = MainTable.SkeletonColor
local Torso_LeftHand_Skeleton = Draw("Line")

Torso_LeftHand_Skeleton.Thickness = 1
Torso_LeftHand_Skeleton.Visible = false
Torso_LeftHand_Skeleton.Transparency = 1
Torso_LeftHand_Skeleton.ZIndex = 1
Torso_LeftHand_Skeleton.Color = MainTable.SkeletonColor
local LowerTorso_RightUpperLeg_Skeleton = Draw("Line")
LowerTorso_RightUpperLeg_Skeleton.Thickness = 1
LowerTorso_RightUpperLeg_Skeleton.Visible = false
LowerTorso_RightUpperLeg_Skeleton.Transparency = 1
LowerTorso_RightUpperLeg_Skeleton.ZIndex = 1
LowerTorso_RightUpperLeg_Skeleton.Color = MainTable.SkeletonColor
local RightUpperLeg_RightLowerLeg_Skeleton = Draw("Line")

RightUpperLeg_RightLowerLeg_Skeleton.Thickness = 1
RightUpperLeg_RightLowerLeg_Skeleton.Visible = false
RightUpperLeg_RightLowerLeg_Skeleton.Transparency = 1
RightUpperLeg_RightLowerLeg_Skeleton.ZIndex = 1
RightUpperLeg_RightLowerLeg_Skeleton.Color = MainTable.SkeletonColor
local RightLowerLeg_RightFoot_Skeleton = Draw("Line")

RightLowerLeg_RightFoot_Skeleton.Thickness = 1
RightLowerLeg_RightFoot_Skeleton.Visible = false
RightLowerLeg_RightFoot_Skeleton.Transparency = 1
RightLowerLeg_RightFoot_Skeleton.ZIndex = 1
RightLowerLeg_RightFoot_Skeleton.Color = MainTable.SkeletonColor
local LowerTorso_LeftUpperLeg_Skeleton = Draw("Line")

LowerTorso_LeftUpperLeg_Skeleton.Thickness = 1
LowerTorso_LeftUpperLeg_Skeleton.Visible = false
LowerTorso_LeftUpperLeg_Skeleton.Transparency = 1
LowerTorso_LeftUpperLeg_Skeleton.ZIndex = 1
LowerTorso_LeftUpperLeg_Skeleton.Color = MainTable.SkeletonColor
local LeftUpperLeg_LeftLowerLeg_Skeleton = Draw("Line")

LeftUpperLeg_LeftLowerLeg_Skeleton.Thickness = 1
LeftUpperLeg_LeftLowerLeg_Skeleton.Visible = false
LeftUpperLeg_LeftLowerLeg_Skeleton.Transparency = 1
LeftUpperLeg_LeftLowerLeg_Skeleton.ZIndex = 1
LeftUpperLeg_LeftLowerLeg_Skeleton.Color = MainTable.SkeletonColor
local LeftLowerLeg_LeftFoot_Skeleton = Draw("Line")

LeftLowerLeg_LeftFoot_Skeleton.Thickness = 1
LeftLowerLeg_LeftFoot_Skeleton.Visible = false
LeftLowerLeg_LeftFoot_Skeleton.Transparency = 1
LeftLowerLeg_LeftFoot_Skeleton.ZIndex = 1
LeftLowerLeg_LeftFoot_Skeleton.Color = MainTable.SkeletonColor
game:GetService("RunService").RenderStepped:Connect(function()
if Player.Character ~= nil and Player ~= game.Players.LocalPlayer and
Player.Character:FindFirstChild("Humanoid") ~= nil and
Player.Character:FindFirstChild("HumanoidRootPart") ~= nil and
game.Players.LocalPlayer.Character ~= nil and
game.Players.LocalPlayer.Character:FindFirstChild("HumanoidRootPart") ~= nil and
Player.Character.Humanoid.Health > 0 and TeamCheck(Player) then
local DistanceAmount =
(game.Players.LocalPlayer.Character.HumanoidRootPart.Position -
Player.Character.HumanoidRootPart.Position).magnitude
local floored = math.floor(DistanceAmount)
if MainTable.DistanceCheck then
if MainTable.DistanceCheckAmount > floored then
local RootVector,OnScreen =
CC:WorldToViewportPoint(Player.Character.HumanoidRootPart.Position)
local HeadVector,Visible =
CC:WorldToViewportPoint(Player.Character.Head.Position)
local LeftFoot,Visible =
CC:WorldToViewportPoint(Player.Character.HumanoidRootPart.Position -
Vector3.new(0,3.4,0))
local HeadV = Camera:WorldToViewportPoint(Player.Character.Head.Position)
local TorsoV =
Camera:WorldToViewportPoint(Player.Character.UpperTorso.Position)
local LowerTorsoV =
Camera:WorldToViewportPoint(Player.Character.LowerTorso.Position)
local RULV =
Camera:WorldToViewportPoint(Player.Character.RightUpperLeg.Position)
local RLLV =
Camera:WorldToViewportPoint(Player.Character.RightLowerLeg.Position)
local RFV =
Camera:WorldToViewportPoint(Player.Character.RightFoot.Position)
local LULV =
Camera:WorldToViewportPoint(Player.Character.LeftUpperLeg.Position)
local LLLV =
Camera:WorldToViewportPoint(Player.Character.LeftLowerLeg.Position)
local LFV = Camera:WorldToViewportPoint(Player.Character.LeftFoot.Position)
local LUAV =
Camera:WorldToViewportPoint(Player.Character.LeftUpperArm.Position)
local LLAV =
Camera:WorldToViewportPoint(Player.Character.LeftLowerArm.Position)
local LHV = Camera:WorldToViewportPoint(Player.Character.LeftHand.Position)
local RUAV =
Camera:WorldToViewportPoint(Player.Character.RightUpperArm.Position)
local RLAV =
Camera:WorldToViewportPoint(Player.Character.RightLowerArm.Position)
local RHV =
Camera:WorldToViewportPoint(Player.Character.RightHand.Position)
if OnScreen then
--//Box\\--
BoxOutline.Size = Vector2.new(2500 / RootVector.Z, HeadVector.Y -
LeftFoot.Y)
Box.Size = Vector2.new(2500 / RootVector.Z, HeadVector.Y - LeftFoot.Y)
BoxOutline.Position = Vector2.new(RootVector.X - BoxOutline.Size.X / 2,

RootVector.Y - BoxOutline.Size.Y / 2)
Box.Position = Vector2.new(RootVector.X - BoxOutline.Size.X / 2,
--//Health Bar\\--
HealthBarOutline.Size = Vector2.new(2, (HeadVector.Y - LeftFoot.Y) /
(Player.Character.Humanoid.MaxHealth / math.clamp(Player.Character.Humanoid.Health,
0, Player.Character.Humanoid.MaxHealth)))
HealthBar.Size = Vector2.new(2, (HeadVector.Y - LeftFoot.Y) /
HealthBarOutline.Position = Vector2.new(Box.Position.X - 8, Box.Position.Y
+ (1 / HealthBarOutline.Size.Y))
HealthBar.Position = Vector2.new(Box.Position.X - 8, Box.Position.Y + (1 /
HealthBar.Size.Y))
--//Health Text\\--
HealthText.Position = Vector2.new(Box.Position.X - 9, HealthBar.Position.Y
+ (1 / HealthBar.Size.Y))
local PlayersHealth = math.floor(Player.Character.Humanoid.Health)

HealthText.Text = tostring(PlayersHealth)
--//NameText\\--
NameText.Position = Vector2.new(HeadVector.X - 40, HeadVector.Y - 30)
local PlayersName = Player.Name

NameText.Text = "["..PlayersName.."]"
--//DistanceText\\--
DistanceText.Position = Vector2.new(RootVector.X, HealthBar.Position.Y + (1
/ HealthBar.Size.Y))
DistanceText.Text = ""..tostring(floored).."m"
Head_Torso_Skeleton.From = Vec2(HeadV.X, HeadV.Y)

Head_Torso_Skeleton.To = Vec2(TorsoV.X, TorsoV.Y)
Torso_LowerTorso_Skeleton.From = Vec2(TorsoV.X, TorsoV.Y)

Torso_LowerTorso_Skeleton.To = Vec2(LowerTorsoV.X, LowerTorsoV.Y)
LowerTorso_RightUpperLeg_Skeleton.From = Vec2(LowerTorsoV.X, LowerTorsoV.Y)

LowerTorso_RightUpperLeg_Skeleton.To = Vec2(RULV.X, RULV.Y)
LowerTorso_LeftUpperLeg_Skeleton.From = Vec2(LowerTorsoV.X, LowerTorsoV.Y)

LowerTorso_LeftUpperLeg_Skeleton.To = Vec2(LULV.X, LULV.Y)
RightUpperLeg_RightLowerLeg_Skeleton.From = Vec2(RULV.X, RULV.Y)

RightUpperLeg_RightLowerLeg_Skeleton.To = Vec2(RLLV.X, RLLV.Y)
RightLowerLeg_RightFoot_Skeleton.From = Vec2(RLLV.X, RLLV.Y)

RightLowerLeg_RightFoot_Skeleton.To = Vec2(RFV.X, RFV.Y)
LeftUpperLeg_LeftLowerLeg_Skeleton.From = Vec2(LULV.X, LULV.Y)

LeftUpperLeg_LeftLowerLeg_Skeleton.To = Vec2(LLLV.X, LLLV.Y)
LeftLowerLeg_LeftFoot_Skeleton.From = Vec2(LLLV.X, LLLV.Y)

LeftLowerLeg_LeftFoot_Skeleton.To = Vec2(LFV.X, LFV.Y)
Torso_RightUpperArm_Skeleton.From = Vec2(TorsoV.X, TorsoV.Y)

Torso_RightUpperArm_Skeleton.To = Vec2(RUAV.X, RUAV.Y)
Torso_RightLowerArm_Skeleton.From = Vec2(RUAV.X, RUAV.Y)

Torso_RightLowerArm_Skeleton.To = Vec2(RLAV.X, RLAV.Y)
Torso_RightHand_Skeleton.From = Vec2(RLAV.X, RLAV.Y)

Torso_RightHand_Skeleton.To = Vec2(RHV.X, RHV.Y)
Torso_LeftUpperArm_Skeleton.From = Vec2(TorsoV.X, TorsoV.Y)

Torso_LeftUpperArm_Skeleton.To = Vec2(LUAV.X, LUAV.Y)
Torso_LeftLowerArm_Skeleton.From = Vec2(LUAV.X, LUAV.Y)

Torso_LeftLowerArm_Skeleton.To = Vec2(LLAV.X, LLAV.Y)
Torso_LeftHand_Skeleton.From = Vec2(LLAV.X, LLAV.Y)

Torso_LeftHand_Skeleton.To = Vec2(LHV.X, LHV.Y)
if MainTable.ESPEnabled then
if MainTable.Box then
BoxOutline.Visible = true
Box.Visible = true
else
Box.Visible = false
end
if MainTable.DistanceText then
DistanceText.Visible = true
else
end
if MainTable.Name then
NameText.Visible = true
else
end
if MainTable.HealthBar then
HealthBarOutline.Visible = true
HealthBar.Visible = true
else
end
if MainTable.HealthText then
HealthText.Visible = true
else
end
if MainTable.Skeleton then
LeftLowerLeg_LeftFoot_Skeleton.Visible = true
LeftUpperLeg_LeftLowerLeg_Skeleton.Visible = true
RightLowerLeg_RightFoot_Skeleton.Visible = true
RightUpperLeg_RightLowerLeg_Skeleton.Visible = true
LowerTorso_LeftUpperLeg_Skeleton.Visible = true
LowerTorso_RightUpperLeg_Skeleton.Visible = true
Torso_LowerTorso_Skeleton.Visible = true
Head_Torso_Skeleton.Visible = true
Torso_LeftUpperArm_Skeleton.Visible = true
Torso_LeftLowerArm_Skeleton.Visible = true
Torso_LeftHand_Skeleton.Visible = true
Torso_RightUpperArm_Skeleton.Visible = true
Torso_RightLowerArm_Skeleton.Visible = true
Torso_RightHand_Skeleton.Visible = true
else
end
else
Box.Visible = false
end
else
Box.Visible = false
end
--
else
Box.Visible = false
end
else
local RootVector,OnScreen =
CC:WorldToViewportPoint(Player.Character.HumanoidRootPart.Position)
local HeadVector,Visible =
CC:WorldToViewportPoint(Player.Character.Head.Position)
local LeftFoot,Visible =
CC:WorldToViewportPoint(Player.Character.HumanoidRootPart.Position -
Vector3.new(0,3.4,0))
local HeadV = Camera:WorldToViewportPoint(Player.Character.Head.Position)
local TorsoV =
Camera:WorldToViewportPoint(Player.Character.UpperTorso.Position)
local LowerTorsoV =
Camera:WorldToViewportPoint(Player.Character.LowerTorso.Position)
local RULV =
Camera:WorldToViewportPoint(Player.Character.RightUpperLeg.Position)
local RLLV =
Camera:WorldToViewportPoint(Player.Character.RightLowerLeg.Position)
local RFV =
Camera:WorldToViewportPoint(Player.Character.RightFoot.Position)
local LULV =
Camera:WorldToViewportPoint(Player.Character.LeftUpperLeg.Position)
local LLLV =
Camera:WorldToViewportPoint(Player.Character.LeftLowerLeg.Position)
local LFV = Camera:WorldToViewportPoint(Player.Character.LeftFoot.Position)
local LUAV =
Camera:WorldToViewportPoint(Player.Character.LeftUpperArm.Position)
local LLAV =
Camera:WorldToViewportPoint(Player.Character.LeftLowerArm.Position)
local LHV = Camera:WorldToViewportPoint(Player.Character.LeftHand.Position)
local RUAV =
Camera:WorldToViewportPoint(Player.Character.RightUpperArm.Position)
local RLAV =
Camera:WorldToViewportPoint(Player.Character.RightLowerArm.Position)
local RHV =
Camera:WorldToViewportPoint(Player.Character.RightHand.Position)
if OnScreen then
--//Box\\--
BoxOutline.Size = Vector2.new(2500 / RootVector.Z, HeadVector.Y -
LeftFoot.Y)
Box.Size = Vector2.new(2500 / RootVector.Z, HeadVector.Y - LeftFoot.Y)
BoxOutline.Position = Vector2.new(RootVector.X - BoxOutline.Size.X / 2,

Box.Position = Vector2.new(RootVector.X - BoxOutline.Size.X / 2,
--//Health Bar\\--
HealthBarOutline.Size = Vector2.new(2, (HeadVector.Y - LeftFoot.Y) /
HealthBar.Size = Vector2.new(2, (HeadVector.Y - LeftFoot.Y) /
HealthBarOutline.Position = Vector2.new(Box.Position.X - 8, Box.Position.Y

+ (1 / HealthBarOutline.Size.Y))
HealthBar.Position = Vector2.new(Box.Position.X - 8, Box.Position.Y + (1 /
HealthBar.Size.Y))
--//Health Text\\--
HealthText.Position = Vector2.new(Box.Position.X - 9, HealthBar.Position.Y
+ (1 / HealthBar.Size.Y))
local PlayersHealth = math.floor(Player.Character.Humanoid.Health)

HealthText.Text = tostring(PlayersHealth)
--//NameText\\--
NameText.Position = Vector2.new(HeadVector.X - 40, HeadVector.Y - 30)
local PlayersName = Player.Name

NameText.Text = "["..PlayersName.."]"
--//DistanceText\\--
DistanceText.Position = Vector2.new(RootVector.X, HealthBar.Position.Y + (1
/ HealthBar.Size.Y))
DistanceText.Text = ""..tostring(floored).."m"
Head_Torso_Skeleton.From = Vec2(HeadV.X, HeadV.Y)

Head_Torso_Skeleton.To = Vec2(TorsoV.X, TorsoV.Y)
Torso_LowerTorso_Skeleton.From = Vec2(TorsoV.X, TorsoV.Y)

Torso_LowerTorso_Skeleton.To = Vec2(LowerTorsoV.X, LowerTorsoV.Y)
LowerTorso_RightUpperLeg_Skeleton.From = Vec2(LowerTorsoV.X, LowerTorsoV.Y)

LowerTorso_RightUpperLeg_Skeleton.To = Vec2(RULV.X, RULV.Y)
LowerTorso_LeftUpperLeg_Skeleton.From = Vec2(LowerTorsoV.X, LowerTorsoV.Y)

LowerTorso_LeftUpperLeg_Skeleton.To = Vec2(LULV.X, LULV.Y)
RightUpperLeg_RightLowerLeg_Skeleton.From = Vec2(RULV.X, RULV.Y)

RightUpperLeg_RightLowerLeg_Skeleton.To = Vec2(RLLV.X, RLLV.Y)
RightLowerLeg_RightFoot_Skeleton.From = Vec2(RLLV.X, RLLV.Y)

RightLowerLeg_RightFoot_Skeleton.To = Vec2(RFV.X, RFV.Y)
LeftUpperLeg_LeftLowerLeg_Skeleton.From = Vec2(LULV.X, LULV.Y)

LeftUpperLeg_LeftLowerLeg_Skeleton.To = Vec2(LLLV.X, LLLV.Y)
LeftLowerLeg_LeftFoot_Skeleton.From = Vec2(LLLV.X, LLLV.Y)

LeftLowerLeg_LeftFoot_Skeleton.To = Vec2(LFV.X, LFV.Y)
Torso_RightUpperArm_Skeleton.From = Vec2(TorsoV.X, TorsoV.Y)

Torso_RightUpperArm_Skeleton.To = Vec2(RUAV.X, RUAV.Y)
Torso_RightLowerArm_Skeleton.From = Vec2(RUAV.X, RUAV.Y)

Torso_RightLowerArm_Skeleton.To = Vec2(RLAV.X, RLAV.Y)
Torso_RightHand_Skeleton.From = Vec2(RLAV.X, RLAV.Y)

Torso_RightHand_Skeleton.To = Vec2(RHV.X, RHV.Y)
Torso_LeftUpperArm_Skeleton.From = Vec2(TorsoV.X, TorsoV.Y)

Torso_LeftUpperArm_Skeleton.To = Vec2(LUAV.X, LUAV.Y)
Torso_LeftLowerArm_Skeleton.From = Vec2(LUAV.X, LUAV.Y)
Torso_LeftLowerArm_Skeleton.To = Vec2(LLAV.X, LLAV.Y)
Torso_LeftHand_Skeleton.From = Vec2(LLAV.X, LLAV.Y)

Torso_LeftHand_Skeleton.To = Vec2(LHV.X, LHV.Y)
if MainTable.ESPEnabled then
if MainTable.Box then
BoxOutline.Visible = true
Box.Visible = true
else
Box.Visible = false
end
if MainTable.DistanceText then
DistanceText.Visible = true
else
end
if MainTable.Name then
NameText.Visible = true
else
end
if MainTable.HealthBar then
HealthBarOutline.Visible = true
HealthBar.Visible = true
else
end
if MainTable.HealthText then
HealthText.Visible = true
else
end
if MainTable.Skeleton then
LeftLowerLeg_LeftFoot_Skeleton.Visible = true
LeftUpperLeg_LeftLowerLeg_Skeleton.Visible = true
RightLowerLeg_RightFoot_Skeleton.Visible = true
RightUpperLeg_RightLowerLeg_Skeleton.Visible = true
LowerTorso_LeftUpperLeg_Skeleton.Visible = true
LowerTorso_RightUpperLeg_Skeleton.Visible = true
Torso_LowerTorso_Skeleton.Visible = true
Head_Torso_Skeleton.Visible = true
Torso_LeftUpperArm_Skeleton.Visible = true
Torso_LeftLowerArm_Skeleton.Visible = true
Torso_LeftHand_Skeleton.Visible = true
Torso_RightUpperArm_Skeleton.Visible = true
Torso_RightLowerArm_Skeleton.Visible = true
Torso_RightHand_Skeleton.Visible = true
else
end
else
Box.Visible = false
end
else
Box.Visible = false
end
end
else
Box.Visible = false
end
end)
end
for i,v in pairs(game.Players:GetChildren()) do

PlayerESP(v)
end
game.Players.PlayerAdded:Connect(function(Players)
PlayerESP(Players)
end)
local WorldSection = VisualsTab:Section({name = "World", side = "right"})
WorldSection:Colorpicker({name = "Ambience", def = game.Lighting.Ambient, callback

= function(v)
game.Lighting.Ambient = v
end})
WorldSection:Slider({name = "Brightness", min = 0, max = 9, dec = 1, suf = "", def

= game.Lighting.Brightness, callback = function(v)
game.Lighting.Brightness = v
end})
WorldSection:Slider({name = "Time", min = 0, max = 24, dec = 1, suf = "hr", def =

math.floor(game.Lighting.ClockTime), callback = function(v)
game.Lighting.ClockTime = v
end})
WorldSection:Slider({name = "Exposure", min = 0, max = 2, dec = 1, suf = "", def =

game.Lighting.ExposureCompensation, callback = function(v)
game.Lighting.ExposureCompensation = v
end})
local CurrentFogStart = game.Lighting.FogStart

local CurrentFogEnd = game.Lighting.FogEnd
WorldSection:Toggle({name = "No Fog", def = false, callback = function(v)

if v then
game.Lighting.FogStart = 100000000
game.Lighting.FogEnd = 100000000
else
game.Lighting.FogStart = CurrentFogStart
game.Lighting.FogEnd = CurrentFogEnd
end
end})
WorldSection:Colorpicker({name = "Fog Color", def = game.Lighting.FogColor,

game.Lighting.FogColor = v
end})
WorldSection:Toggle({name = "Shadows", def = game.Lighting.GlobalShadows, callback

= function(v)
game.Lighting.GlobalShadows = v
end})
local ScreenSection = VisualsTab:Section({name = "Screen", side = "right"})
ScreenSection:Toggle({name = "Aspect Ratio", def = false, callback = function(v)

MainTable.AspectRatio = v
end})
ScreenSection:Slider({name = "Ratio", min = 1, max = 100, dec = 1, suf = "%", def =

100, callback = function(v)
MainTable.Ratio = v
end})
OldNewIndex = hookmetamethod(game, "__newindex", function(self, Key, Value)

if (self == game.Workspace.CurrentCamera and Key == "CFrame") and
MainTable.AspectRatio then
local X, Y, Z, R00, R01, R02, R10, R11, R12, R20, R21, R22 =
Value:GetComponents()
Value = CFrame.new(X, Y, Z, R00, R01 * MainTable.Ratio / 100, R02, R10, R11
* MainTable.Ratio / 100, R12, R20, R21 * MainTable.Ratio / 100, R22)
end
return OldNewIndex(self, Key, Value)
end)
local PlayersSection = MiscTab:Section({name = "Players", side = "left"})
local PlayersTable = {}
for i,v in pairs(game.Players:GetPlayers()) do
table.insert(PlayersTable,v.Name)
end
local PlayersDropdown = PlayersSection:Dropdown({name = "Selection", options =

PlayersTable, def = LocalPlayer.Name, mutli = false, scrollable = true, vis = 6,
min = 6, callback = function(y)
getgenv().SelectedPlayer = y
end})
Players.PlayerAdded:Connect(function(child)
for i,v in pairs(PlayersTable) do
if v == child.Name then
table.insert(PlayersTable,i)
PlayersDropdown:Refresh(PlayersTable)
end
end
end)
Players.PlayerRemoving:Connect(function(child)
for i,v in pairs(PlayersTable) do
if v == child.Name then
table.remove(PlayersTable,i)
PlayersDropdown:Refresh(PlayersTable)
end
end
end)
PlayersSection:Button({name = "Teleport", callback = function()

if getgenv().SelectedPlayer then
local PlayerCFrame =
game.Players[getgenv().SelectedPlayer].Character.HumanoidRootPart.CFrame
game.Players.LocalPlayer.Character.HumanoidRootPart.CFrame = PlayerCFrame
end
end})
PlayersSection:Button({name = "View", callback = function(c)

local Camera = game.Workspace.Camera
Camera.CameraSubject =
game.Players[getgenv().SelectedPlayer].Character.Humanoid
end
end})
PlayersSection:Button({name = "Copy User Id", callback = function(c)

setclipboard(tostring(game.Players[getgenv().SelectedPlayer].UserId))
end
end})
PlayersSection:Button({name = "Highlight", callback = function(c)

local CurrentPlayer = game.Players[getgenv().SelectedPlayer]
if CurrentPlayer.Character ~= nil and
CurrentPlayer.Character:FindFirstChild("Humanoid") and
CurrentPlayer.Character.Humanoid.Health ~= 0 then
if CurrentPlayer.Character:FindFirstChildOfClass("Highlight") then
CurrentPlayer.Character:FindFirstChildOfClass("Highlight"):Destroy()
else
local PlayerHighlight = Instance.new("Highlight")
PlayerHighlight.Parent = CurrentPlayer.Character
end
end
end
end})
local MovementSection = MiscTab:Section({name = "Movement", side = "right"})
MovementSection:Toggle({name = "Speed Multiplier", def = false, callback =

function(c)
MainTable.SpeedMultiplier = c
end})
local SpeedLoop = game:GetService("RunService").Heartbeat:Connect(function()

if MainTable.SpeedMultiplier then
game.Players.LocalPlayer.Character.HumanoidRootPart.CFrame =
game.Players.LocalPlayer.Character.HumanoidRootPart.CFrame +
game.Players.LocalPlayer.Character.Humanoid.MoveDirection * MainTable.Speed
end
end)
MovementSection:Slider({name = "Speed Amount", min = 0, max = 100, dec = 1, suf =

"%", def = 0, callback = function(v)
MainTable.Speed = v/20
end})
local MenuSection = SettingsTab:Section({name = "Menu", side = "left"})
MenuSection:Toggle({name = "Keybind List", def = false, callback = function(v)

if library.loaded then
Window.kblist:ShowHideFromMyLifePleaseSomebodyKillMeIDontWantToBeAliveRightNowImUse
lessInMyLife(v)
end
end})
local UserInputService = game:GetService("UserInputService")
--UI Toggling
UserInputService.InputBegan:Connect(function(Key, Event)
if (Key.KeyCode == MenuBind) then
Window:Fade()
end
end)
Window:Init()
return library, utility

Message

Uploaded by

Copyright:

Available Formats

Message

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Message

Uploaded by

Copyright:

Available Formats

--[[

local uis = game:GetService("UserInputService")

local lplr = plrs.LocalPlayer

local v2new = Vector2.new

local c3rgb, c3hsv = Color3.fromRGB, Color3.fromHSV

-- // 24 december 2022: added groups to make my life easier

function utility:Draw(class, offset, properties, t)

local draw = Drawing.new(class)

if properties and properties.Parent then

rawset(fakeDraw, "Lerp", function(to, time, removeOld)

if lerpLoop ~= nil and removeOld then

local loop; loop = rs.Heartbeat:Connect(function(delta)

if elapsed == time then

local ptc = (elapsed / time)

elapsed = math.clamp(elapsed + delta, 0, time)

if class == "Square" or class == "Circle" or class == "Line" then

if class ~= "Image" then

if not library.loaded and not t then

function utility:Image(object, link)

function utility:Connect(connection, func)

function utility:BindToRenderStep(name, priority, func)

function utility:Combine(t1, t2)

-- // xyl thanks for the method cause im npc

-- // function i will never use?

-- // totally not pasted from splix (100%)

utility.short_keybind_names = {["MouseButton1"] = "MB1", ["MouseButton2"] =

function library.Window(self, info, theme)

local name = info.name or "worst ui library ever"

local main_frame = utility:Draw("Square", nil, {

local main_frame_outline = utility:Draw("Square", v2new(-1, -1), {

local main_frame_accent = utility:Draw("Square", v2new(-2, -2), {

local main_frame_title = utility:Draw("Text", v2new(3, 2), {

local pretab_frame = utility:Draw("Square", v2new(6, 20), {

local pretab_frame_inline = utility:Draw("Square", v2new(-1, -1), {

local pretab_frame_outline = utility:Draw("Square", v2new(-2, -2), {

local tabs_frame = utility:Draw("Square", v2new(6, 23), {

local tab_frame_accent = utility:Draw("Square", v2zero, {

local tabs_frame_outline = utility:Draw("Square", v2new(-1, -1), {

function window.Tab(self, info)

local name = info.name or "tab"

local offset = v2new(0, -19)

if #self.tabs > 0 then

local tab_frame = utility:Draw("Square", offset, {

local tab_frame_outline = utility:Draw("Square", v2new(-1, -1), {

local tab_frame_text = utility:Draw("Text", v2new(tab_frame.Size.X / 2, 2),

local tab_frame_hider = utility:Draw("Square", v2new(0, tab_frame.Size.Y),

tab.instances = {tab_frame, tab_frame_outline, tab_frame_text,

-- // loop for every side (left, right)

for sn, side in pairs(self.sides) do

-- // update it's size

-- // if its not first section

-- // last section_frame instance

local last_sframe = side[i - 1].instances[1]

-- // set new section_frame instance offset with counting

offset = offset + last_sframe.GetOffset().Y +

tab_frame.Color = self.on and window.theme.lcont or window.theme.dcont

function tab.Section(self, info)

if side ~= "left" and side ~= "right" then

local section = {name = name, side = side, instances = {}, scale = 0,