621 lines
22 KiB
Lua
621 lines
22 KiB
Lua
--[[
|
|
Created by Scriptkia : https://github.com/Scriptkia
|
|
Redistributed by WeAreDevs: https://wearedevs.net/scripts
|
|
]]
|
|
|
|
local UserInputService = game:GetService("UserInputService")
|
|
local ReplicatedStorage = game:GetService("ReplicatedStorage")
|
|
local RunService = game:GetService("RunService")
|
|
local Players = game:GetService("Players")
|
|
local Teams = game:GetService("Teams")
|
|
local LocalPlayer = Players.LocalPlayer
|
|
|
|
local Exploit = (syn and "Synapse")
|
|
local HttpRequest = syn.request
|
|
local GetGarbageCollection = getgc
|
|
local MoveMouse = mousemoverel
|
|
local ProtectGui = syn.protect_gui
|
|
local IsLuaClosure = islclosure
|
|
local IsExploitFunction = is_synapse_function
|
|
local NewCClosure = newcclosure
|
|
local HookFunction = hookfunction
|
|
local WindowActive = iswindowactive
|
|
local GetConnections = getconnections
|
|
|
|
local GetUpValues = (getupvalues or debug.getupvalues)
|
|
local GetUpValue = (getupvalue or debug.getupvalue)
|
|
local SetUpValue = (setupvalue or debug.setupvalue)
|
|
local GetConstants = (getconstants or debug.getconstants)
|
|
local GetConstant = (getconstant or debug.getconstant)
|
|
local SetConstant = (setconstant or debug.setconstant)
|
|
local GetProtos = (getprotos or debug.getprotos)
|
|
local GetProto = (getproto or debug.getproto)
|
|
local SetProto = (setproto or debug.setproto)
|
|
local GetInfo = (getinfo or debug.getinfo)
|
|
local GetRegistry = (getreg or debug.getregistry)
|
|
|
|
local SetReadOnly = setreadonly
|
|
local IsReadOnly = isreadonly
|
|
local CheckCaller = checkcaller
|
|
local GetNamecallMethod = getnamecallmethod
|
|
local GetRawMetatable = getrawmetatable
|
|
local SetRawMetatable = setrawmetatable
|
|
|
|
local GetGlobalEnvironment = getgenv
|
|
local GetModuleEnvironment = getmenv
|
|
local GetScriptEnvironment = getsenv
|
|
local GetRobloxEnvironment = getrenv
|
|
|
|
local CIELUV = loadstring(game:HttpGet("https://raw.githubusercontent.com/coastss/releases/main/cieluv_color_lerp.lua"))()
|
|
local Library = loadstring(game:HttpGet("https://pastebin.com/raw/edJT9EGX"))()
|
|
local HealthbarLerp = CIELUV:Lerp(Color3.fromRGB(255, 0, 0), Color3.fromRGB(0, 255, 0))
|
|
|
|
local Visuals = {Players = {}} do
|
|
local DrawingProperties = {
|
|
Line = {
|
|
Thickness = 1.5,
|
|
Color = Color3.fromRGB(255, 255, 255),
|
|
Visible = false
|
|
},
|
|
Text = {
|
|
Size = 16,
|
|
Center = true,
|
|
Outline = true,
|
|
Color = Color3.fromRGB(255, 255, 255),
|
|
Visible = false
|
|
},
|
|
Circle = {
|
|
Thickness = 1.5,
|
|
NumSides = 100,
|
|
Radius = 0,
|
|
Filled = false,
|
|
Color = Color3.fromRGB(255, 255, 255),
|
|
Visible = false
|
|
},
|
|
Square = {
|
|
Thickness = 1.5,
|
|
Filled = false,
|
|
Color = Color3.fromRGB(255, 255, 255),
|
|
Visible = false
|
|
},
|
|
Image = {
|
|
Rounding = 0,
|
|
Visible = false
|
|
}
|
|
}
|
|
|
|
function Visuals:Round(Number, Bracket)
|
|
Bracket = (Bracket or 1)
|
|
|
|
if typeof(Number) == "Vector2" then
|
|
return Vector2.new(Visuals:Round(Number.X), Visuals:Round(Number.Y))
|
|
else
|
|
return (Number - Number % (Bracket or 1))
|
|
end
|
|
end
|
|
|
|
function Visuals:GetScreenPosition(Position)
|
|
local Position, Visible = Workspace.CurrentCamera:WorldToViewportPoint(Position)
|
|
local FullPosition = Position
|
|
Position = Vector2.new(Position.X, Position.Y)
|
|
|
|
return Position, Visible, FullPosition
|
|
end
|
|
|
|
function Visuals:CreateDrawing(Type, Custom)
|
|
local Drawing = Drawing.new(Type)
|
|
|
|
for Property, Value in pairs(DrawingProperties[Type]) do
|
|
Drawing[Property] = Value
|
|
end
|
|
|
|
if Custom then
|
|
for Property, Value in pairs(Custom) do
|
|
Drawing[Property] = Value
|
|
end
|
|
end
|
|
|
|
return Drawing
|
|
end
|
|
|
|
function Visuals.AddPlayer(Player)
|
|
if not Visuals.Players[Player] then
|
|
Visuals.Players[Player] = {
|
|
Box = {
|
|
Outline = Visuals:CreateDrawing("Square", {Color = Color3.fromRGB(0, 0, 0)}),
|
|
Main = Visuals:CreateDrawing("Square")
|
|
--// Main = Visuals:CreateDrawing("Image", {Data = game:HttpGet("https://coasts.cool/uploads/48ny7FCjZ9iCmbAwlirI.png")})
|
|
|
|
},
|
|
Healthbar = {
|
|
Outline = Visuals:CreateDrawing("Square", {Filled = true, Color = Color3.fromRGB(0, 0, 0)}),
|
|
Main = Visuals:CreateDrawing("Square", {Filled = true, Color = Color3.fromRGB(0, 255, 0)})
|
|
},
|
|
Info = {
|
|
Main = Visuals:CreateDrawing("Text"),
|
|
Extra = Visuals:CreateDrawing("Text")
|
|
}
|
|
}
|
|
end
|
|
end
|
|
|
|
function Visuals.RemovePlayer(Player)
|
|
if Visuals.Players[Player] then
|
|
for Index, Table in pairs(Visuals.Players[Player]) do
|
|
for Index2, Drawing in pairs(Table) do
|
|
if Drawing.Remove then
|
|
Drawing:Remove()
|
|
end
|
|
end
|
|
end
|
|
|
|
Visuals.Players[Player] = nil
|
|
end
|
|
end
|
|
end
|
|
|
|
local Connections = {AllConnections = {}} do
|
|
function Connections:Add(Name, Connection, Callback)
|
|
if not Connections.AllConnections[Name] then
|
|
Connection:Connect(Callback)
|
|
Connections.AllConnections[Name] = Connection
|
|
end
|
|
end
|
|
|
|
function Connections:Remove(Name)
|
|
local Connection = Connections.AllConnections[Name]
|
|
|
|
if Connection then
|
|
Connection:Disconnect()
|
|
end
|
|
end
|
|
end
|
|
|
|
local PlayerUtilities = {} do
|
|
function PlayerUtilities:IsPlayerAlive(Player)
|
|
local Character = Player.Character
|
|
local Humanoid = (Character and Character:FindFirstChildWhichIsA("Humanoid"))
|
|
|
|
if Character and Humanoid then
|
|
if Humanoid.Health > 0 then
|
|
return true
|
|
end
|
|
end
|
|
|
|
return false
|
|
end
|
|
|
|
function PlayerUtilities:GetHealth(Player)
|
|
local Character = Player.Character
|
|
local Humanoid = (Character and Character:FindFirstChildWhichIsA("Humanoid"))
|
|
|
|
if Character and Humanoid then
|
|
return {
|
|
CurrentHealth = Humanoid.Health,
|
|
MaxHealth = Humanoid.MaxHealth
|
|
}
|
|
end
|
|
end
|
|
|
|
function PlayerUtilities:GetBodyParts(Player)
|
|
local Character = Player.Character
|
|
local Head = (Character and Character:FindFirstChild("Head"))
|
|
local Root = (Character and Character:FindFirstChild("HumanoidRootPart"))
|
|
local Torso = Character and (Character:FindFirstChild("LowerTorso") or Character:FindFirstChild("Torso"))
|
|
local LeftArm = Character and (Character:FindFirstChild("LeftLowerArm") or Character:FindFirstChild("Left Arm"))
|
|
local RightArm = Character and (Character:FindFirstChild("RightLowerArm") or Character:FindFirstChild("Right Arm"))
|
|
local LeftLeg = Character and (Character:FindFirstChild("LeftLowerLeg") or Character:FindFirstChild("Left Leg"))
|
|
local RightLeg = Character and (Character:FindFirstChild("RightLowerLeg") or Character:FindFirstChild("Right Leg"))
|
|
|
|
if Character and (Head and Root and Torso and LeftArm and RightArm and LeftLeg and RightLeg) then
|
|
return {
|
|
Character = Character,
|
|
Head = Head,
|
|
Root = Root,
|
|
Torso = Torso,
|
|
LeftArm = LeftArm,
|
|
RightArm = RightArm,
|
|
LeftLeg = LeftLeg,
|
|
RightLeg = RightLeg
|
|
}
|
|
end
|
|
end
|
|
|
|
function PlayerUtilities:GetTeamColor(Player)
|
|
return Player.TeamColor.Color
|
|
end
|
|
|
|
function PlayerUtilities:IsOnClientTeam(Player)
|
|
if LocalPlayer.Team == Player.Team then
|
|
return true
|
|
end
|
|
|
|
return false
|
|
end
|
|
|
|
function PlayerUtilities:GetDistanceFromClient(Position)
|
|
return LocalPlayer:DistanceFromCharacter(Position)
|
|
end
|
|
|
|
function PlayerUtilities:GetClosestPlayer()
|
|
local ClosestPlayer = nil
|
|
local FarthestDistance = math.huge
|
|
|
|
for Index, Player in pairs(Players:GetPlayers()) do
|
|
if Player == LocalPlayer then continue end
|
|
|
|
local PassedTeamCheck = true
|
|
local IsPlayerAlive = PlayerUtilities:IsPlayerAlive(Player)
|
|
local Health = PlayerUtilities:GetHealth(Player)
|
|
local BodyParts = PlayerUtilities:GetBodyParts(Player)
|
|
local IsOnClientTeam = PlayerUtilities:IsOnClientTeam(Player)
|
|
|
|
if Library.flags["Aimbot Team Check"] and IsOnClientTeam then
|
|
PassedTeamCheck = false
|
|
end
|
|
|
|
if IsPlayerAlive and Health and BodyParts and PassedTeamCheck then
|
|
local ScreenPosition, OnScreen = Visuals:GetScreenPosition(BodyParts.Root.Position)
|
|
|
|
if ScreenPosition and OnScreen then
|
|
local MouseDistance = (ScreenPosition - UserInputService:GetMouseLocation()).Magnitude
|
|
|
|
if MouseDistance < FarthestDistance then
|
|
if Library.flags["Aimbot Use FOV"] then
|
|
if MouseDistance <= Library.flags["Aimbot FOV Radius"] then
|
|
FarthestDistance = MouseDistance
|
|
ClosestPlayer = {
|
|
Player = Player,
|
|
BodyParts = BodyParts
|
|
}
|
|
end
|
|
else
|
|
FarthestDistance = MouseDistance
|
|
ClosestPlayer = {
|
|
Player = Player,
|
|
BodyParts = BodyParts
|
|
}
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
return ClosestPlayer
|
|
end
|
|
|
|
function PlayerUtilities:AimAt(Position, Smoothing)
|
|
local MouseLocation = UserInputService:GetMouseLocation()
|
|
MoveMouse(((Position.X - MouseLocation.X) / Smoothing), ((Position.Y - MouseLocation.Y) / Smoothing))
|
|
end
|
|
end
|
|
|
|
for Index, Player in pairs(Players:GetPlayers()) do
|
|
if Player == LocalPlayer then continue end
|
|
Visuals.AddPlayer(Player)
|
|
end
|
|
|
|
local FOVCircle = Visuals:CreateDrawing("Circle")
|
|
local Games = {
|
|
[113491250] = "Phantom Forces",
|
|
[1168263273] = "Bad Business"
|
|
}
|
|
|
|
local Game = Games[game.GameId]
|
|
if Game == "Phantom Forces" then
|
|
local GetBodyParts = nil
|
|
local GetPlayerHealth = nil
|
|
|
|
for Index, Value in pairs(GetGarbageCollection(true)) do
|
|
if typeof(Value) == "table" then
|
|
if rawget(Value, "getbodyparts") then
|
|
GetBodyParts = Value.getbodyparts
|
|
end
|
|
|
|
if rawget(Value, "getplayerhealth") then
|
|
GetPlayerHealth = Value.getplayerhealth
|
|
end
|
|
end
|
|
end
|
|
|
|
if not GetBodyParts or not GetPlayerHealth then return end
|
|
|
|
function PlayerUtilities:IsPlayerAlive(Player)
|
|
local PlayerHealth = GetPlayerHealth(Player, Player)
|
|
|
|
if PlayerHealth then
|
|
if math.floor(PlayerHealth) > 0 then
|
|
return true
|
|
end
|
|
end
|
|
|
|
return false
|
|
end
|
|
|
|
function PlayerUtilities:GetHealth(Player)
|
|
local PlayerHealth = GetPlayerHealth(Player, Player)
|
|
|
|
if PlayerHealth then
|
|
return {
|
|
CurrentHealth = math.floor(PlayerHealth),
|
|
MaxHealth = 100
|
|
}
|
|
end
|
|
end
|
|
|
|
function PlayerUtilities:GetBodyParts(Player)
|
|
local BodyParts = GetBodyParts(Player)
|
|
|
|
if BodyParts and BodyParts.rootpart then
|
|
return {
|
|
Character = BodyParts.rootpart.Parent,
|
|
Head = BodyParts.head,
|
|
Root = BodyParts.rootpart,
|
|
Torso = BodyParts.torso,
|
|
LeftArm = BodyParts.larm,
|
|
RightArm = BodyParts.rarm,
|
|
LeftLeg = BodyParts.lleg,
|
|
RightLeg = BodyParts.rleg
|
|
}
|
|
end
|
|
end
|
|
|
|
function PlayerUtilities:AimAt(Position, Smoothing)
|
|
local MouseLocation = UserInputService:GetMouseLocation()
|
|
Smoothing += 0.5
|
|
MoveMouse(((Position.X - MouseLocation.X) / Smoothing), ((Position.Y - MouseLocation.Y) / Smoothing))
|
|
end
|
|
elseif Game == "Bad Business" then
|
|
local TS = require(ReplicatedStorage:WaitForChild("TS"))
|
|
|
|
function PlayerUtilities:IsPlayerAlive(Player)
|
|
local Character = TS.Characters:GetCharacter(Player)
|
|
local Health = (Character and Character:FindFirstChild("Health"))
|
|
|
|
if Character and Health then
|
|
if Health.Value > 0 then
|
|
return true
|
|
end
|
|
end
|
|
|
|
return false
|
|
end
|
|
|
|
function PlayerUtilities:GetHealth(Player)
|
|
local Character = TS.Characters:GetCharacter(Player)
|
|
local Health = (Character and Character:FindFirstChild("Health"))
|
|
|
|
if Character and (Health and Health:FindFirstChild("MaxHealth")) then
|
|
return {
|
|
CurrentHealth = Health.Value,
|
|
MaxHealth = Health.MaxHealth.Value
|
|
}
|
|
end
|
|
end
|
|
|
|
function PlayerUtilities:GetBodyParts(Player)
|
|
local Character = TS.Characters:GetCharacter(Player)
|
|
local Body = (Character and Character:FindFirstChild("Body"))
|
|
|
|
if Character and Body then
|
|
local Head = (Body and Body:FindFirstChild("Head"))
|
|
local Root = (Character and Character:FindFirstChild("Root"))
|
|
local Torso = (Body and Body:FindFirstChild("Chest"))
|
|
local LeftArm = (Body and Body:FindFirstChild("LeftArm"))
|
|
local RightArm = (Body and Body:FindFirstChild("RightArm"))
|
|
local LeftLeg = (Body and Body:FindFirstChild("LeftLeg"))
|
|
local RightLeg = (Body and Body:FindFirstChild("RightLeg"))
|
|
|
|
if Character and (Head and Root and Torso and LeftArm and RightArm and LeftLeg and RightLeg) then
|
|
return {
|
|
Character = Character,
|
|
Head = Head,
|
|
Root = Root,
|
|
Torso = Torso,
|
|
LeftArm = LeftArm,
|
|
RightArm = RightArm,
|
|
LeftLeg = LeftLeg,
|
|
RightLeg = RightLeg
|
|
}
|
|
end
|
|
end
|
|
end
|
|
|
|
function PlayerUtilities:GetDistanceFromClient(Position)
|
|
local ClientBodyParts = PlayerUtilities:GetBodyParts(LocalPlayer)
|
|
|
|
if ClientBodyParts then
|
|
return (Position - ClientBodyParts.Root.Position).Magnitude
|
|
end
|
|
|
|
return 0
|
|
end
|
|
|
|
function PlayerUtilities:GetTeamColor(Player)
|
|
return Teams[TS.Teams:GetPlayerTeam(Player)].Color.Value
|
|
end
|
|
|
|
function PlayerUtilities:IsOnClientTeam(Player)
|
|
return TS.Teams:ArePlayersFriendly(Player, LocalPlayer)
|
|
end
|
|
end
|
|
|
|
Connections:Add("VisualsPlayerAdded", Players.PlayerAdded, Visuals.AddPlayer)
|
|
Connections:Add("VisualsPlayerRemoved", Players.PlayerRemoving, Visuals.RemovePlayer)
|
|
Connections:Add("UniversalRenderStepped", RunService.RenderStepped, function()
|
|
FOVCircle.Position = UserInputService:GetMouseLocation()
|
|
FOVCircle.Radius = Library.flags["Aimbot FOV Radius"]
|
|
FOVCircle.Color = Library.flags["Aimbot FOV Color"]
|
|
FOVCircle.Visible = ((Library.flags["Aimbot Enabled"] and Library.flags["Aimbot Use FOV"]) and true) or false
|
|
|
|
if Library.flags["Aimbot Enabled"] and Library.flags["Aimbot Active"] then
|
|
local ClosestPlayer = PlayerUtilities:GetClosestPlayer()
|
|
|
|
if ClosestPlayer and (ClosestPlayer.Player and ClosestPlayer.BodyParts) then
|
|
local ScreenPosition, OnScreen = Visuals:GetScreenPosition(ClosestPlayer.BodyParts.Head.Position)
|
|
|
|
if ScreenPosition and OnScreen then
|
|
PlayerUtilities:AimAt(ScreenPosition, Library.flags["Aimbot Smoothing"])
|
|
end
|
|
end
|
|
end
|
|
|
|
for Index, Player in pairs(Players:GetPlayers()) do
|
|
if Player == LocalPlayer then continue end
|
|
|
|
local Objects = Visuals.Players[Player]
|
|
if not Objects then continue end
|
|
|
|
local OnScreen, PassedTeamCheck = false, true
|
|
local IsPlayerAlive = PlayerUtilities:IsPlayerAlive(Player)
|
|
local Health = PlayerUtilities:GetHealth(Player)
|
|
local BodyParts = PlayerUtilities:GetBodyParts(Player)
|
|
local PlayerColor = (PlayerUtilities:IsOnClientTeam(Player) and Library.flags["Visuals Ally Color"]) or Library.flags["Visuals Enemy Color"]
|
|
local IsOnClientTeam = PlayerUtilities:IsOnClientTeam(Player)
|
|
|
|
if Library.flags["Visuals Use Team Color"] then
|
|
PlayerColor = PlayerUtilities:GetTeamColor(Player)
|
|
end
|
|
|
|
if Library.flags["Visuals Team Check"] and IsOnClientTeam then
|
|
PassedTeamCheck = false
|
|
end
|
|
|
|
if IsPlayerAlive and Health and BodyParts and PlayerColor and PassedTeamCheck then
|
|
local HealthPercent = (Health.CurrentHealth / Health.MaxHealth)
|
|
local Distance = PlayerUtilities:GetDistanceFromClient(BodyParts.Root.Position)
|
|
ScreenPosition, OnScreen = Visuals:GetScreenPosition(BodyParts.Root.Position)
|
|
|
|
local Orientation, Size = BodyParts.Character:GetBoundingBox()
|
|
local Height = (Workspace.CurrentCamera.CFrame - Workspace.CurrentCamera.CFrame.Position) * Vector3.new(0, (math.clamp(Size.Y, 1, 10) + 0.5) / 2, 0)
|
|
Height = math.abs(Workspace.CurrentCamera:WorldToScreenPoint(Orientation.Position + Height).Y - Workspace.CurrentCamera:WorldToScreenPoint(Orientation.Position - Height).Y)
|
|
Size = Visuals:Round(Vector2.new((Height / 2), Height))
|
|
|
|
local NameString = string.format("%s", Player.Name)
|
|
|
|
if Player.DisplayName ~= Player.Name then
|
|
NameString = string.format("%s | %s", Player.Name, Player.DisplayName)
|
|
end
|
|
|
|
Objects.Box.Main.Color = PlayerColor
|
|
Objects.Box.Main.Size = Size
|
|
Objects.Box.Main.Position = Visuals:Round(Vector2.new(ScreenPosition.X, ScreenPosition.Y) - (Size / 2))
|
|
function Visuals:Round(Number, Bracket)
|
|
Bracket = (Bracket or 1)
|
|
|
|
if typeof(Number) == "Vector2" then
|
|
return Vector2.new(Visuals:Round(Number.X), Visuals:Round(Number.Y))
|
|
else
|
|
return (Number - Number % (Bracket or 1))
|
|
end
|
|
end
|
|
|
|
Objects.Box.Outline.Thickness = (Objects.Box.Main.Thickness * 2)
|
|
Objects.Box.Outline.Size = Objects.Box.Main.Size
|
|
Objects.Box.Outline.Position = Objects.Box.Main.Position
|
|
|
|
Objects.Healthbar.Main.Color = HealthbarLerp(HealthPercent)
|
|
Objects.Healthbar.Main.Size = Vector2.new(2, (-Objects.Box.Main.Size.Y * HealthPercent))
|
|
Objects.Healthbar.Main.Position = Vector2.new((Objects.Box.Main.Position.X - (Objects.Box.Outline.Thickness + 1)), (Objects.Box.Main.Position.Y + Objects.Box.Main.Size.Y))
|
|
|
|
Objects.Healthbar.Outline.Size = Vector2.new(4, (Objects.Box.Main.Size.Y + 2))
|
|
Objects.Healthbar.Outline.Position = Vector2.new((Objects.Box.Main.Position.X - (Objects.Box.Outline.Thickness + 2)), (Objects.Box.Main.Position.Y - 1))
|
|
|
|
Objects.Info.Main.Font = Drawing.Fonts[Library.flags["Visuals Info Font"]]
|
|
Objects.Info.Main.Text = NameString
|
|
Objects.Info.Main.Position = Vector2.new(((Objects.Box.Main.Size.X / 2) + Objects.Box.Main.Position.X), ((ScreenPosition.Y - Objects.Box.Main.Size.Y / 2) - 18))
|
|
|
|
Objects.Info.Extra.Font = Drawing.Fonts[Library.flags["Visuals Info Font"]]
|
|
Objects.Info.Extra.Text = string.format("(%dft) (%d/%d)", Distance, Health.CurrentHealth, Health.MaxHealth)
|
|
Objects.Info.Extra.Position = Vector2.new(((Objects.Box.Main.Size.X / 2) + Objects.Box.Main.Position.X), (Objects.Box.Main.Size.Y + Objects.Box.Main.Position.Y))
|
|
end
|
|
|
|
Objects.Box.Main.Visible = (OnScreen and Library.flags["Visuals Show Boxes"]) or false
|
|
Objects.Box.Outline.Visible = Objects.Box.Main.Visible
|
|
|
|
Objects.Healthbar.Main.Visible = (OnScreen and Library.flags["Visuals Show Healthbar"]) or false
|
|
Objects.Healthbar.Outline.Visible = Objects.Healthbar.Main.Visible
|
|
|
|
Objects.Info.Main.Visible = (OnScreen and Library.flags["Visuals Show Info"]) or false
|
|
Objects.Info.Extra.Visible = (OnScreen and Library.flags["Visuals Show Extra Info"]) or false
|
|
end
|
|
end)
|
|
|
|
local Fonts = {} do
|
|
for Font, Number in pairs(Drawing.Fonts) do
|
|
table.insert(Fonts, Font)
|
|
end
|
|
end
|
|
|
|
Library.flags["Aimbot Active"] = false
|
|
|
|
local AimbotTab = Library:CreateWindow("Aimbot")
|
|
AimbotTab:AddToggle({text = "Enabled", flag = "Aimbot Enabled"})
|
|
AimbotTab:AddToggle({text = "Use Field of View", flag = "Aimbot Use FOV"})
|
|
AimbotTab:AddToggle({text = "Team Check", flag = "Aimbot Team Check"})
|
|
AimbotTab:AddBind({
|
|
text = "Bind",
|
|
flag = "Aimbot Bind",
|
|
key = Enum.UserInputType.MouseButton2,
|
|
hold = true,
|
|
callback = function(Value)
|
|
Library.flags["Aimbot Active"] = (not Value)
|
|
end
|
|
})
|
|
|
|
AimbotTab:AddSlider({
|
|
text = "FOV Radius",
|
|
flag = "Aimbot FOV Radius",
|
|
min = 0,
|
|
max = 500,
|
|
float = 1
|
|
})
|
|
|
|
AimbotTab:AddSlider({
|
|
text = "Smoothing",
|
|
flag = "Aimbot Smoothing",
|
|
min = 1,
|
|
max = 5,
|
|
float = 0.1
|
|
})
|
|
|
|
AimbotTab:AddColor({
|
|
text = "FOV Circle Color",
|
|
flag = "Aimbot FOV Color",
|
|
color = Color3.fromRGB(255, 255, 255)
|
|
})
|
|
|
|
local VisualsTab = Library:CreateWindow("Visuals")
|
|
VisualsTab:AddToggle({text = "Boxes", flag = "Visuals Show Boxes"})
|
|
VisualsTab:AddToggle({text = "Healthbar", flag = "Visuals Show Healthbar"})
|
|
VisualsTab:AddToggle({text = "Info", flag = "Visuals Show Info"})
|
|
VisualsTab:AddToggle({text = "Extra Info", flag = "Visuals Show Extra Info"})
|
|
VisualsTab:AddToggle({text = "Use Team Color", flag = "Visuals Use Team Color"})
|
|
VisualsTab:AddToggle({text = "Team Check", flag = "Visuals Team Check"})
|
|
VisualsTab:AddList({
|
|
text = "Info Font",
|
|
flag = "Visuals Info Font",
|
|
values = Fonts
|
|
})
|
|
|
|
VisualsTab:AddColor({
|
|
text = "Ally Color",
|
|
flag = "Visuals Ally Color",
|
|
color = Color3.fromRGB(0, 255, 0)
|
|
})
|
|
|
|
VisualsTab:AddColor({
|
|
text = "Enemy Color",
|
|
flag = "Visuals Enemy Color",
|
|
color = Color3.fromRGB(255, 0, 0)
|
|
})
|
|
|
|
Library:Init()
|
|
|
|
UserInputService.InputBegan:Connect(function(Input, GameProcessedEvent)
|
|
if GameProcessedEvent then return end
|
|
if Input.KeyCode == Enum.KeyCode.RightControl then
|
|
Library:Close()
|
|
end
|
|
end)
|