Last active
November 3, 2021 21:56
-
-
Save A1-exe/eaea4194ddc4a2e8d726717b3d706201 to your computer and use it in GitHub Desktop.
latest first person shooter stuff
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
--[[ | |
__/\\\\____________/\\\\_________________________________________________________ | |
_\/\\\\\\________/\\\\\\_________________________________________________________ | |
_\/\\\//\\\____/\\\//\\\_________________________________________________________ | |
_\/\\\\///\\\/\\\/_\/\\\_____/\\\\\_____/\\/\\\\\\\___/\\\\\\\\\\_____/\\\\\\\\__ | |
_\/\\\__\///\\\/___\/\\\___/\\\///\\\__\/\\\/////\\\_\/\\\//////____/\\\/////\\\_ | |
_\/\\\____\///_____\/\\\__/\\\__\//\\\_\/\\\___\///__\/\\\\\\\\\\__/\\\\\\\\\\\__ | |
_\/\\\_____________\/\\\_\//\\\__/\\\__\/\\\_________\////////\\\_\//\\///////___ | |
_\/\\\_____________\/\\\__\///\\\\\/___\/\\\__________/\\\\\\\\\\__\//\\\\\\\\\\_ | |
_\///______________\///_____\/////_____\///__________\//////////____\//////////__ | |
[A1.exe#1168] | |
FIRST PERSON SHOOTERS | |
------------------------ | |
-: CHANGELOG :- | |
------------------------ | |
4.5.3: | |
-- Added `protect_gui` to UI instances on synapse | |
- Significant Performance Enhancements (Shouldn't lag as much on any game) | |
- Aimbot now has range instead of depth | |
- Aimbot has mode option now | |
- Fixed ESP to cycle between 'All', 'Players', 'NPCs' | |
- Fixed Chams Transparency | |
- 4.x emphasizes the focus on including NPCs | |
- Completely rewrote ESP | |
- Completely rewrote Chams | |
- Aimbot uses mouse (Change Depth if it doesn't Detect NPCs) | |
- Changed default chams transparency to 0.9 | |
------------------------ | |
-: NOTES :- | |
------------------------ | |
- Pressing `Esc` lets u focus on using this menu fully | |
- This script relies heavily on Synapse's anti CoreGui detection methods. | |
- Use at your own risk. | |
- This script is laggy on some games... It is what it is. | |
- Games with custom drag implementations kinda screw this script | |
Esp: | |
- This is pretty much safe. | |
Chams: | |
- This is very easily detected. | |
- Be careful using this. | |
Aimbot: | |
- This is pretty much safe, as it | |
relies entirely on dragging the mouse. | |
- Works better on lower sensitivities | |
- Players within CloseRange (75 studs) | |
are targeted by who's closest. | |
- Increase depth to search workspace | |
further. Some games hide NPCs deeper in folders. | |
Fullbright: | |
- Messes with stuff, might get you banned. | |
Floaty: | |
- Messes with stuff, might get you banned. | |
------------------------ | |
-: CONTROLS :- | |
------------------------ | |
Menu: | |
Delete - Toggle | |
Chams: | |
Click [Toggle] to cycle colors | |
Aimbot: | |
H - Toggle | |
U - Up | |
J - Down | |
Floaty: | |
N - Still | |
B - Up | |
M - Down | |
--]] | |
local GameSettings = UserSettings():GetService('UserGameSettings') | |
local CoreGUI = game:GetService('CoreGui') | |
local Run = game:GetService('RunService'); | |
local World = game:GetService('Workspace'); | |
local Input = game:GetService('UserInputService'); | |
local Lighting = game:GetService('Lighting'); | |
local Players = game:GetService('Players'); | |
local Player = Players['LocalPlayer']; | |
local PlayerMouse = Player:GetMouse() | |
local PlayerCamera = World.CurrentCamera | |
local PlayerModel = Player.Character or Player.CharacterAdded:wait() | |
local Temp = {} | |
local Targets = {} | |
local Inputs = {} | |
local Keys = {} | |
local Events = { | |
Targets = Instance.new('BindableEvent') | |
} | |
local Settings = { | |
-- Order and Defaults -- | |
Menu = { | |
Defaults = { | |
{'Menu', false, Enum.KeyCode.Delete}, | |
{'Team Chams', true, '<-'}, | |
{'Enemy Chams', true, '<-'}, | |
{'Toggle Chams', true, '<-'}, | |
{'Fullbright', true, '\'MAX\''}, | |
{'Floaty', true, '\'Still\''}, | |
{'Aimbot', true, '<-'}, | |
{'Aimbot Mode', false, '<-'}, | |
{'ESP', true, '<-'}, | |
{'Written by: A1.exe#1168', false, 'Discord'} | |
}, | |
Colors = { | |
Enabled = Color3.fromRGB(46, 105, 132), | |
Disabled = Color3.fromRGB(97, 97, 97), | |
} | |
}, | |
--- ESP --- | |
ESP = { | |
Enabled = false, | |
Options = {'All', 'Players', 'NPCs'}, | |
Current = 1 | |
}, | |
--- Chams --- | |
Chams = { | |
Enabled = false, | |
Transparency = 0.9, | |
Team = { | |
Enabled = false, | |
Color = {'Grey', Color3.fromRGB(204, 204, 204)} | |
}, | |
Enemy = { | |
Enabled = false, | |
Color = {'Red', Color3.fromRGB(255, 0, 0)} | |
}, | |
Colors = { | |
{'White', Color3.fromRGB(255, 255, 255)}, | |
{'Black', Color3.fromRGB(0, 0, 0)}, | |
{'Grey', Color3.fromRGB(204, 204, 204)}, | |
{'Red', Color3.fromRGB(255, 0, 0)}, | |
{'Yellow', Color3.fromRGB(255, 255, 0)}, | |
{'Purple', Color3.fromRGB(166, 0, 166)}, | |
{'Blue', Color3.fromRGB(0, 0, 255)}, | |
{'Green', Color3.fromRGB(0, 255, 0)}, | |
}, | |
}, | |
--- Aimbot --- | |
Aimbot = { | |
Enabled = false, | |
Mode = 1, | |
ModeOptions = {'All', 'Players', 'NPCs'}, | |
Range = 1, | |
RangeOptions = {math.huge, 100, 250, 500, 750, 1000, 1250, 1500, 1750, 2000, 2500, 5000}, | |
CloseRange = 75, | |
Selection = {}, | |
Selected = 1, | |
Scrolled = 0, | |
Status = {}, | |
Menu = { | |
{'Enabled', false}, -- // Toggle aimbot | |
{'TeamCheck', false}, -- // Check team | |
{'HeadsOnly', false}, -- // Only target head | |
{'Shake', true}, -- // Shake mouse between body and head | |
{'RayCheck', true}, -- // Obstacles exist | |
{'CamCheck', false}, -- // Don't check inside the camera | |
{'AutoAim', false}, -- // No need to hold mouse | |
{'Hide Menu', false}, -- // Hide the ui | |
} | |
}, | |
--- Floaty --- | |
Floaty = { | |
Enabled = false, | |
Height = 3.9, | |
Current = 1, | |
Options = {'Still', 'Up', 'Down'} | |
}, | |
--- Fullbright --- | |
Fullbright = { | |
Enabled = false, | |
Current = 1, | |
Options = {'Max', 'Half', 'Default'}, | |
OptionDefs = { | |
Max = { | |
Fog = 1000000, | |
Brightness = 10, | |
InAmbience = Color3.new(1, 1, 1), | |
OutAmbience = Color3.new(1, 1, 1), | |
}, | |
Half = { | |
Fog = 250, | |
Brightness = 1.5, | |
InAmbience = Color3.fromRGB(153, 153, 153), | |
OutAmbience = Color3.fromRGB(153, 153, 153), | |
}, | |
Default = { | |
Fog = Lighting.FogEnd, | |
Brightness = Lighting.Brightness, | |
InAmbience = Lighting.Ambient, | |
OutAmbience = Lighting.OutdoorAmbient | |
} | |
} | |
} | |
} | |
---- LOAD EVENTS ---- | |
for name, tab in next, (Settings) do | |
Events[name] = Instance.new('BindableEvent') | |
end | |
--------------------- | |
local function GetFunc(tab, name) | |
for funcName, func in next, (tab) do | |
if funcName == name then | |
return func, funcName | |
end | |
end | |
end | |
local function GetColor(tab, name) | |
for index, colortab in next, (tab) do | |
if (colortab[1] == name) then | |
return colortab, index | |
elseif (colortab[2] == name) then | |
return colortab, index | |
end | |
end | |
end | |
------------ [[ GUI SPAWN ]] ------------ | |
FormAssets = function() | |
------ ERROR MAGIC ------ | |
local __ERROR__ = Instance.new('BindableEvent') | |
__ERROR__['Event']:Connect(error) | |
--------- CREATE FUNCTION --------- | |
local create = function(class, parent) | |
local instance = Instance.new(class); | |
if instance:IsA('GuiObject') and syn and syn.protect_gui then | |
syn.protect_gui(instance) | |
end | |
return function(props) | |
for property, value in next, (props) do | |
if (property ~= 'Parent') and (typeof(value) ~= 'Instance') then | |
local suc, err = pcall(function() | |
instance[property] = value | |
end) | |
if not suc then __ERROR__:Fire('[Script->Asset]: ' .. err) end | |
elseif (property == 'Parent') then | |
parent = value | |
end | |
end | |
if parent and (typeof(parent) == 'Instance') then | |
instance['Parent'] = parent | |
end | |
return instance | |
end | |
end | |
------------------------------------- | |
------------------------------------- | |
-- SOME THINGS MAY BE OUT OF ORDER -- | |
----(INSTANCE RELATED PROPERTIES)---- | |
-------------(UNLIKELY)-------------- | |
------------------------------------- | |
------------------------------------- | |
local Main = create('ScreenGui'){ | |
Name = 'FPS Hacks - Menu' | |
} | |
local Folder = create('Folder', Main){ | |
Name = 'Chams' | |
} | |
local Folder1 = create('Folder', Folder){ | |
Name = 'Team' | |
} | |
local Folder2 = create('Folder', Folder){ | |
Name = 'Enemy' | |
} | |
local Folder3 = create('Folder', Main){ | |
Name = 'ESP' | |
} | |
local Frame = create('Frame', Main){ | |
Name = 'Main'; | |
BackgroundColor3 = Color3.new(1, 1, 1); | |
BackgroundTransparency = 1; | |
Position = UDim2.new(0.5, 0, 0.5, 0); | |
Size = UDim2.new(0, 250, 0, 190); | |
Draggable = true; | |
Active = true; | |
AnchorPoint = Vector2.new(0.5, 0.5); | |
Transparency = 1 | |
} | |
local TextLabel = create('TextLabel', Frame){ | |
Name = 'Title'; | |
BackgroundColor3 = Color3.new(0.180392, 0.411765, 0.517647); | |
BorderSizePixel = 0; | |
Size = UDim2.new(1, 0, 0, 35); | |
Text = 'FPS Hacks v4.5.3'; | |
TextColor3 = Color3.new(0.866667, 0.843137, 0.843137); | |
Font = Enum.Font.SciFi; | |
FontSize = Enum.FontSize.Size28; | |
TextWrapped = true | |
} | |
local ScrollingFrame = create('ScrollingFrame', Frame){ | |
Name = 'Buttons'; | |
BackgroundColor3 = Color3.new(1, 1, 1); | |
BackgroundTransparency = 1; | |
BorderSizePixel = 0; | |
Position = UDim2.new(0.5, 0, 0, 40); | |
CanvasSize = UDim2.new(0, 0, 0, 0); | |
Size = UDim2.new(1, 0, 0, 290); | |
AnchorPoint = Vector2.new(0.5, 0); | |
Transparency = 1 | |
} | |
local Frame1 = create('Frame'){ | |
BackgroundColor3 = Color3.new(1, 1, 1); | |
BackgroundTransparency = 1; | |
BorderSizePixel = 0; | |
Position = UDim2.new(0, 0, 0, 1); | |
Selectable = true; | |
Size = UDim2.new(1, 0, 0, 25); | |
ClipsDescendants = true; | |
Transparency = 1 | |
} | |
local TextLabel1 = create('TextButton', Frame1){ | |
Name = 'Text'; | |
BackgroundColor3 = Color3.new(1, 1, 1); | |
BorderColor3 = Color3.new(0.180392, 0.411765, 0.517647); | |
Position = UDim2.new(0.100000001, 0, 0, 0); | |
Size = UDim2.new(0.600000024, 0, 1, 0); | |
Text = 'Example'; | |
TextColor3 = Color3.new(0.180392, 0.411765, 0.517647); | |
Font = Enum.Font.SciFi; | |
FontSize = Enum.FontSize.Size14 | |
} | |
local Frame2 = create('Frame', Frame1){ | |
Name = 'Status'; | |
BackgroundColor3 = Color3.new(0, 1, 0); | |
BorderSizePixel = 0; | |
Position = UDim2.new(0.0250000004, 0, 0.5, 0); | |
Size = UDim2.new(0, 7, 0, 7); | |
Style = Enum.FrameStyle.DropShadow; | |
AnchorPoint = Vector2.new(0, 0.5) | |
} | |
local TextButton = create('TextButton', Frame1){ | |
Name = 'Key'; | |
BackgroundColor3 = Color3.new(0.180392, 0.411765, 0.517647); | |
BackgroundTransparency = 0.5; | |
BorderSizePixel = 0; | |
Position = UDim2.new(0.699999988, 0, 0, 0); | |
Size = UDim2.new(0.300000012, 0, 1, 0); | |
Text = '[EXAMPLE]'; | |
TextColor3 = Color3.new(0.839216, 0.839216, 0.839216); | |
Font = Enum.Font.SciFi; | |
FontSize = Enum.FontSize.Size14; | |
TextStrokeColor3 = Color3.new(0.380392, 0.380392, 0.380392); | |
TextStrokeTransparency = 0; | |
Transparency = 0.5 | |
} | |
local UIListLayout = create('UIListLayout', ScrollingFrame){ | |
Padding = UDim.new(0, 4); | |
HorizontalAlignment = Enum.HorizontalAlignment.Center | |
} | |
local UIPadding = create('UIPadding', ScrollingFrame){} | |
local ESP_GUI = create('BillboardGui'){ | |
Active = true; | |
AlwaysOnTop = true; | |
StudsOffsetWorldSpace = Vector3.new(0, 4, 0); | |
Size = UDim2.new(0, 100, 0, 50) | |
} | |
create('TextLabel', ESP_GUI){ | |
Name = 'Target'; | |
BackgroundColor3 = Color3.new(1, 1, 1); | |
BackgroundTransparency = 1; | |
BorderSizePixel = 0; | |
Size = UDim2.new(1, 0, 0, 20); | |
Text = ''; | |
TextColor3 = Color3.new(1, 0, 0); | |
Font = Enum.Font.GothamBlack; | |
TextSize = 16; | |
TextScaled = true; | |
TextStrokeTransparency = 0.20000000298023; | |
TextWrapped = true | |
} | |
create('TextLabel', ESP_GUI){ | |
Name = 'Dist'; | |
BackgroundColor3 = Color3.new(1, 1, 1); | |
BackgroundTransparency = 1; | |
Position = UDim2.new(0, 0, 0.349999994, 0); | |
Size = UDim2.new(1, 0, 0, 20); | |
Text = ''; | |
TextColor3 = Color3.new(1, 0, 0.498039); | |
Font = Enum.Font.Ubuntu; | |
FontSize = Enum.FontSize.Size14; | |
TextScaled = true; | |
TextStrokeTransparency = 0.20000000298023; | |
TextWrapped = true | |
} | |
local Float = function() | |
return create('Part', World){ | |
Size = Vector3.new(6, 1.8, 6); | |
Transparency = 1; | |
CanCollide = false; | |
Anchored = true | |
} | |
end | |
return create, Main, Frame1, Folder, Folder3, ESP_GUI, Float | |
end | |
local Create, Menu, Button, Chams, ESPFolder, Billboard, Float = FormAssets() | |
local Functions; | |
Functions = { | |
['Menu'] = function() | |
Menu['Enabled'] = not (Menu['Enabled']); | |
end; | |
['Floaty'] = function(change) | |
local FloatySettings = Settings.Floaty | |
if not Floaty then Floaty = Float() end | |
if (change:lower() == 'toggle') then | |
FloatySettings.Enabled = not FloatySettings.Enabled | |
end | |
if (change:lower() == 'up') then | |
FloatySettings.Height = 2 | |
FloatySettings.UI.Key.Text = '[ \'UP\' ]' | |
return | |
elseif (change:lower() == 'still') then | |
FloatySettings.Height = 3.9 | |
FloatySettings.UI.Key.Text = '[ \'STILL\' ]' | |
return | |
elseif (change:lower() == 'down') then | |
FloatySettings.Height = 6 | |
FloatySettings.UI.Key.Text = '[ \'DOWN\' ]' | |
return | |
end | |
if FloatySettings.Enabled then | |
Floaty.CanCollide = true | |
coroutine.wrap(function() | |
while FloatySettings.Enabled and wait() and Floaty do | |
local Char = Player.Character or Player.CharacterAdded:wait() | |
local RootPart = Char and Char:FindFirstChild('HumanoidRootPart') | |
if RootPart then | |
Floaty.CFrame = CFrame.new(RootPart.CFrame.x, RootPart.CFrame.y - FloatySettings.Height, RootPart.CFrame.z) | |
end | |
end | |
if Foaty then | |
Floaty.CanCollide = false | |
end | |
end)() | |
elseif Floaty then | |
Floaty.CanCollide = false | |
end | |
end; | |
['ESP'] = function() | |
local ESPSettings = Settings.ESP | |
ESPSettings.Enabled = not ESPSettings.Enabled | |
ESPFolder:ClearAllChildren() | |
if ESPSettings.Enabled then | |
if Temp['ESP'] then | |
Temp['ESP']:Disconnect() | |
Temp['ESP'] = nil | |
end | |
local function HandleESP(model, player) | |
if (player == Player) then return end | |
local RootPart = model:WaitForChild('HumanoidRootPart', 1) | |
if not RootPart then return end | |
local Bill = Billboard:Clone() | |
local Folder, targetCon, playerCon; | |
local modeModel = (player and ESPSettings.Options[2]) or ESPSettings.Options[3] | |
local modeESP = ESPSettings.Options[ESPSettings.Current] | |
if player then | |
local name = player['Name'] | |
if (#name > 20) then | |
name = name:sub(1, 20) .. '...' | |
end | |
local teammate = (player.TeamColor == Player.TeamColor) | |
Folder = Create('Folder', ESPFolder){Name = name} | |
Bill.Target.Text = name..(((player.TeamColor == Player.TeamColor) and ' [T]') or '') | |
Bill.Target.TextColor3 = player.TeamColor.Color | |
local function teamChanged() | |
local name = player['Name'] | |
if (#name > 20) then | |
name = name:sub(1, 20) .. '...' | |
end | |
Bill.Target.Text = name..(((player.TeamColor == Player.TeamColor) and ' [T]') or '') | |
Bill.Target.TextColor3 = player.TeamColor.Color | |
end | |
targetCon = player:GetPropertyChangedSignal('TeamColor'):Connect(teamChanged) | |
playerCon = Player:GetPropertyChangedSignal('TeamColor'):Connect(teamChanged) | |
else | |
local name = model['Name'] | |
if (#name > 20) then | |
name = name:sub(1, 20) .. '...' | |
end | |
Folder = Create('Folder', ESPFolder){Name = 'NPC: '..name} | |
Bill.Target.Text = 'NPC: '..name | |
end | |
Bill.Enabled = (ESPSettings.Current == 1) or (modeESP == modeModel) | |
Bill.Adornee = RootPart | |
Bill.Parent = Folder | |
local modeChanged = Events.ESP.Event:Connect(function(kind) | |
if kind == 'change' then | |
modeESP = ESPSettings.Options[ESPSettings.Current] | |
Bill.Enabled = (ESPSettings.Current == 1) or (modeESP == modeModel) | |
end | |
end) | |
while model:IsDescendantOf(World) and Folder:IsDescendantOf(CoreGUI) and ESPSettings.Enabled do | |
local CHRP = PlayerModel and PlayerModel:FindFirstChild('HumanoidRootPart') | |
if CHRP then | |
Bill.Dist.Text = math.floor((RootPart.Position - CHRP.Position).magnitude) | |
end | |
wait() | |
end | |
Folder.Parent = nil | |
if targetCon then targetCon:Disconnect() end | |
if playerCon then playerCon:Disconnect() end | |
modeChanged:Disconnect() | |
end | |
for model, player in next, (Targets) do | |
if not ESPSettings.Enabled then | |
break | |
end | |
coroutine.wrap(function() | |
HandleESP(model, player) | |
end)() | |
end | |
if not ESPSettings.Enabled then return end | |
Temp['ESP'] = Events.Targets.Event:Connect(function(kind, model) | |
if (kind == 'added') then | |
coroutine.wrap(function() | |
HandleESP(model, Targets[model]) | |
end)() | |
end | |
end) | |
elseif Temp['ESP'] then | |
Temp['ESP']:Disconnect() | |
Temp['ESP'] = nil | |
end | |
end, | |
['Team Chams'] = function(mainbutton) | |
local TeamSettings = Settings.Chams.Team | |
if mainbutton then | |
TeamSettings.Enabled = not TeamSettings.Enabled | |
end | |
for __, handle in next, (Chams['Team']:GetDescendants()) do | |
if handle:IsA('BoxHandleAdornment') then | |
handle.Color3 = TeamSettings.Color[2] | |
handle.Visible = TeamSettings.Enabled | |
end | |
end | |
end, | |
['Enemy Chams'] = function(mainbutton) | |
local ChamSettings = Settings.Chams | |
local EnemySettings = ChamSettings.Enemy | |
if mainbutton then | |
EnemySettings.Enabled = not EnemySettings.Enabled | |
end | |
for __, handle in next, (Chams['Enemy']:GetDescendants()) do | |
if handle:IsA('BoxHandleAdornment') then | |
handle.Color3 = EnemySettings.Color[2] | |
handle.Visible = EnemySettings.Enabled | |
end | |
end | |
end, | |
['Toggle Chams'] = function() | |
local ChamSettings = Settings.Chams | |
local TeamSettings = ChamSettings.Team | |
local EnemySettings = ChamSettings.Enemy | |
ChamSettings.Enabled = not ChamSettings.Enabled | |
Chams['Team']:ClearAllChildren() | |
Chams['Enemy']:ClearAllChildren() | |
if ChamSettings.Enabled then | |
local function HandleChams(model, player) | |
if (player == Player) then return end | |
local RootPart = model:WaitForChild('HumanoidRootPart', 1) | |
if not RootPart or (not player and #model:GetDescendants() > 300) then | |
return | |
end | |
local Folder, FoldCon, pTeamCon, PTeamCon, ModelCon; | |
local isFriendly = player and (player.TeamColor == Player.TeamColor) | |
if player then | |
Folder = Create('Folder', (isFriendly and Chams['Team']) or Chams['Enemy']){Name = player['Name']} | |
local function teamChanged() | |
if not Folder:IsDescendantOf(CoreGUI) then | |
if pTeamCon then pTeamCon:Disconnect() end | |
if PTeamCon then PTeamCon:Disconnect() end | |
return | |
end | |
isFriendly = (player.TeamColor == Player.TeamColor) | |
if isFriendly then | |
if Folder:IsDescendantOf(Chams['Enemy']) then | |
Folder.Parent = Chams['Team'] | |
end | |
for __, handle in next, (Folder:GetChildren()) do | |
handle.Color3 = TeamSettings.Color[2] | |
handle.Visible = TeamSettings.Enabled | |
end | |
else | |
if Folder:IsDescendantOf(Chams['Team']) then | |
Folder.Parent = Chams['Enemy'] | |
end | |
for __, handle in next, (Folder:GetChildren()) do | |
handle.Color3 = EnemySettings.Color[2] | |
handle.Visible = EnemySettings.Enabled | |
end | |
end | |
end | |
pTeamCon = player:GetPropertyChangedSignal('TeamColor'):Connect(teamChanged) | |
PTeamCon = Player:GetPropertyChangedSignal('TeamColor'):Connect(teamChanged) | |
else | |
Folder = Create('Folder', Chams['Enemy']){Name = model['Name']} | |
end | |
for __, part in next, (model:GetChildren()) do | |
if part:IsA('BasePart') then | |
if isFriendly then | |
Create('BoxHandleAdornment', Folder) | |
{ | |
Color3 = TeamSettings.Color[2]; | |
AlwaysOnTop = true; | |
Transparency = ChamSettings.Transparency; | |
Visible = TeamSettings.Enabled; | |
ZIndex = 10; | |
Size = (part['Name'] == 'Head' and Vector3.new(1.25, 1.3, 1.25)) | |
or (Vector3.new(.5, .5, .5) + part.Size) | |
}['Adornee'] = part | |
else | |
Create('BoxHandleAdornment', Folder) | |
{ | |
Color3 = EnemySettings.Color[2]; | |
AlwaysOnTop = true; | |
Transparency = ChamSettings.Transparency; | |
Visible = EnemySettings.Enabled; | |
ZIndex = 10; | |
Size = (part['Name'] == 'Head' and Vector3.new(1.25, 1.3, 1.25)) | |
or (Vector3.new(.5, .5, .5) + part.Size) | |
}['Adornee'] = part | |
end | |
end | |
end | |
FoldCon = Folder:GetPropertyChangedSignal('Parent'):Connect(function() | |
if not Folder:IsDescendantOf(CoreGUI) then | |
if pTeamCon then pTeamCon:Disconnect() end | |
if PTeamCon then PTeamCon:Disconnect() end | |
if ModelCon then ModelCon:Disconnect() end | |
FoldCon:Disconnect() | |
end | |
end) | |
if not model:IsDescendantOf(World) or not Folder:IsDescendantOf(CoreGUI) then | |
if pTeamCon then pTeamCon:Disconnect() end | |
if PTeamCon then PTeamCon:Disconnect() end | |
if FoldCon then FoldCon:Disconnect() end | |
Folder.Parent = nil | |
end | |
ModelCon = Events.Targets.Event:Connect(function(kind, rmodel) | |
if (kind == 'removed') and (rmodel == model) then | |
if pTeamCon then pTeamCon:Disconnect() end | |
if PTeamCon then PTeamCon:Disconnect() end | |
if FoldCon then FoldCon:Disconnect() end | |
Folder.Parent = nil | |
ModelCon:Disconnect() | |
end | |
end) | |
end | |
for model, player in next, (Targets) do | |
if not ChamSettings.Enabled then | |
break | |
end | |
coroutine.wrap(function() | |
HandleChams(model, player) | |
end)() | |
end | |
if not ChamSettings.Enabled then return end | |
Temp['Chams'] = Events.Targets.Event:Connect(function(kind, model) | |
if (kind == 'added') then | |
coroutine.wrap(function() | |
HandleChams(model, Targets[model]) | |
end)() | |
end | |
end) | |
elseif Temp['Chams'] then | |
Temp['Chams']:Disconnect() | |
Temp['Chams'] = nil | |
end | |
end, | |
['Fullbright'] = function(mainbutton) | |
local Fullbright = Settings.Fullbright | |
if mainbutton then | |
Fullbright.Enabled = not Fullbright.Enabled | |
end | |
local function Handle() | |
local Setting = Fullbright.Options[Fullbright.Current] | |
local Settings = Fullbright.OptionDefs[Setting] | |
Fullbright.UI.Key['Text'] = '[ \'' .. Setting .. '\' ]' | |
Lighting.Ambient = Settings.InAmbience; | |
Lighting.OutdoorAmbient = Settings.OutAmbience; | |
Lighting.Brightness = Settings.Brightness; | |
Lighting.FogStart = Settings.Fog; | |
Lighting.FogEnd = Settings.Fog; | |
end | |
if (not Fullbright.Enabled) then | |
Fullbright.Current = 3 | |
end | |
Handle() | |
end; | |
['Aimbot'] = function(Aimbot) | |
local IgnorePlayersNamed = {A1_exe=true} -- Name = true or false | |
--[[ | |
[J] - To go down the list. | |
[U] - To go up the list. | |
[H] - To toggle that item in the list. | |
[RMB] - To aim at your target using the current settings. (THIS UPDATES IN LIVE TIME SO YOU DON'T HAVE TO STOP AIMING FOR IT TO TAKE EFFECT) | |
--]] | |
local ResizeUI = function(ui,downscale,byclass) | |
if not rawequal(ui['ClassName'], 'ScrollingFrame') then return end | |
local count = 0; | |
for __, asset in next, (ui:GetChildren()) do | |
if rawequal(asset['ClassName'],byclass) then | |
count = count + 1 | |
end | |
end | |
ui['CanvasSize'] = UDim2.new(ui.CanvasSize.X.Scale,ui.CanvasSize.X.Offset,ui.CanvasSize.Y.Scale,downscale*count) | |
end | |
local ffc, ffoc, cast, ray = World.FindFirstChild, World.FindFirstChildOfClass, World.FindPartOnRayWithIgnoreList, Ray.new | |
local selection, status = Aimbot.Selection, Aimbot.Status | |
local MakeAimUI = function() | |
local GUI = Create('ScreenGui', CoreGUI){ | |
Name = '___'; | |
On | |
} | |
local Frame = Create('ScrollingFrame', GUI){ | |
BackgroundTransparency = 1, | |
BorderSizePixel = 0, | |
Name = 'Options', | |
Position = UDim2.new(.8,0,.915,0), | |
Size = UDim2.new(.2,0,0,30), | |
ZIndex = 10, | |
ClipsDescendants = true, | |
CanvasSize = UDim2.new(0,0,0,0), | |
CanvasPosition = Vector2.new(0, current_pos), | |
ScrollBarThickness = 0, | |
ScrollingEnabled = false, | |
} | |
local UILL = Create('UIListLayout', Frame){ | |
Name = 'LayoutHandler', | |
FillDirection = 'Vertical', | |
HorizontalAlignment = 'Center', | |
SortOrder = 'LayoutOrder', | |
VerticalAlignment = 'Top' | |
} | |
local Template = Create('TextButton'){ | |
BackgroundTransparency = 1, | |
BorderSizePixel = 0, | |
Name = 'Template', | |
Size = UDim2.new(.9,0,0,30), | |
Font = 'SciFi', | |
Text = '', | |
TextColor3 = Color3.fromRGB(255,255,255), | |
TextScaled = true, | |
TextWrapped = true, | |
} | |
local TSC = Create('UISizeConstraint', Template){ | |
Name = 'TemplateSizeConstraint', | |
MaxSize = Vector2.new(math.huge,30), | |
} | |
Frame['ChildAdded']:Connect(function() | |
ResizeUI(Frame, 30, 'TextButton') | |
end) | |
for ___, packed_option in next, Aimbot.Menu do | |
local option, val = unpack(packed_option) | |
status[option] = val | |
local tp = Template:Clone() | |
tp.LayoutOrder = sel_pos | |
tp.Name = option | |
if option:match('Hide') then | |
tp.Text = ':: ' .. option .. ' ::' | |
tp.TextColor3 = Color3.fromRGB(220, 100, 220) | |
else | |
tp.Text = option .. ': ' .. tostring(val) | |
if status[option] then | |
tp.TextColor3 = Color3.fromRGB(0,255,0) | |
else | |
tp.TextColor3 = Color3.fromRGB(255,0,0) | |
end | |
end | |
table.insert(selection, tp) | |
tp.Parent = Frame | |
end | |
return Frame | |
end | |
local ActiveUI = MakeAimUI() | |
Aimbot.ActiveUI = ActiveUI | |
local function cast_ray(p0,p1,blacklist) | |
local Part | |
local __=0 | |
repeat | |
__=__+1 | |
local cond=(p1-p0).magnitude < 999 | |
Part,p0=cast(workspace,ray(p0,cond and p1-p0 or (p1-p0).unit*999),blacklist) | |
if Part then | |
local pname = tostring(Part):lower() | |
if Part.CanCollide == false or Part.Transparency >= 0.7 or ((pname:match('glass') or pname:match('window')) and Part.Transparency >= .3) or ffoc(Part.Parent, 'Humanoid') then | |
blacklist[#blacklist+1]=Part | |
Part=nil | |
end | |
elseif cond or __ > 15 then | |
break | |
end | |
until Part | |
return Part,p0 | |
end | |
Run.RenderStepped:Connect(function() | |
if status['Enabled'] and (Inputs[Enum.UserInputType.MouseButton2] or status['AutoAim']) then | |
local close, range, dot, face = false, math.huge, -1 | |
for model, player in next, (Targets) do | |
if (player == Player) then continue end | |
if not status['CamCheck'] and model:IsDescendantOf(PlayerCamera) then | |
continue | |
end | |
local modeModel = (player and Aimbot.ModeOptions[2]) or Aimbot.ModeOptions[3] | |
local modeAimbot = Aimbot.ModeOptions[Aimbot.Mode] | |
if (Aimbot.Mode ~= 1) and (modeModel ~= modeAimbot) then | |
continue | |
end | |
local hum = ffoc(model, 'Humanoid') | |
local root = ffc(model, 'HumanoidRootPart') | |
local head = ffc(model, 'Head') | |
if not Inputs[Enum.UserInputType.MouseButton2] and not status['AutoAim'] then return end | |
if IgnorePlayersNamed[model['Name']] or (player and IgnorePlayersNamed[player['Name']]) or ffoc(model, 'ForceField') then continue end | |
if not root or (status['HeadsOnly'] and not head) then continue end | |
if hum and hum['Health'] > 0 then | |
if player and status['TeamCheck'] then | |
if Player['TeamColor'] == player['TeamColor'] then | |
continue | |
end | |
end | |
local cc = PlayerCamera.CFrame | |
local pos = ((head and (status['HeadsOnly'] or (status['Shake'] and math.random(1, 10) < 6))) and head.Position) or root.Position | |
local dist = (pos-cc.p).magnitude | |
local RangeVal = Aimbot.RangeOptions[Aimbot.Range] | |
if (RangeVal ~= math.huge) and (dist > RangeVal) then | |
continue | |
end | |
local hitPart; | |
if status['RayCheck'] then | |
hitPart = cast_ray(cc.p,pos,{PlayerCamera,PlayerModel}) | |
end | |
if not (status['RayCheck'] and hitPart) or model:IsAncestorOf(hitPart) then | |
local m = (pos-cc.p).unit:Dot(cc.lookVector) | |
if (dist <= Aimbot.CloseRange) then | |
close = true | |
end | |
if close then | |
if (dist < range) then | |
dot, face, range = m, pos, dist | |
end | |
elseif (m > dot) then | |
dot, face, range = m, pos, dist | |
end | |
end | |
end | |
end | |
if face then | |
--PlayerCamera.CFrame = CFrame.new(PlayerCamera.CFrame.p,face) * CFrame.new(0,0,0.5) | |
if iswindowactive() then | |
local Pos, InFront = PlayerCamera:WorldToScreenPoint(face) | |
local TargetX, TargetY = (InFront and Pos.x) or -Pos.x, Pos.y | |
local MouseX, MouseY = PlayerMouse.X, PlayerMouse.Y | |
local NewX, NewY = math.abs(MouseX - TargetX), math.abs(MouseY - TargetY) | |
local Inc = GameSettings.MouseSensitivity * (17/3) | |
if (MouseX > TargetX) then | |
NewX = -NewX/Inc | |
else | |
NewX = NewX/Inc | |
end | |
if (MouseY > TargetY) then | |
NewY = -NewY/Inc | |
else | |
NewY = NewY/Inc | |
end | |
mousemoverel(NewX, NewY) | |
end | |
end | |
end | |
end) | |
end | |
} | |
for __, option in next, (Settings.Menu.Defaults) do | |
local Name, Functional, Setting = unpack(option) | |
local Func = GetFunc(Functions, Name) | |
local NewOption = Button:Clone() | |
if Name == 'Menu' or Name:match('Written') then | |
NewOption['Status']['Style'] = 'Custom'; | |
NewOption['Key']['TextStrokeColor3'] = Settings.Menu.Colors.Enabled | |
end | |
NewOption['Text'].Text = Name | |
NewOption['Key'].Text = '[ '.. ((typeof(Setting) == 'EnumItem' and Setting.Name) or Setting) .. ' ]' | |
NewOption.Parent = Menu['Main']['Buttons'] | |
if Func then | |
NewOption['Text']['MouseButton1Down']:Connect(function() | |
if not Functional then return end | |
if NewOption.Status.Style.Name == 'DropShadow' then | |
NewOption.Status.Style = 'Custom' | |
NewOption['Key']['TextStrokeColor3'] = Settings.Menu.Colors.Enabled | |
elseif NewOption.Status.Style.Name == 'Custom' and not Name:match('Aimbot') then | |
NewOption.Status.Style = 'DropShadow' | |
NewOption['Key']['TextStrokeColor3'] = Settings.Menu.Colors.Disabled | |
end | |
if (Name == 'Aimbot') and not Settings.Aimbot.Enabled then | |
Settings.Aimbot.Enabled = true | |
-- Activate Mode UI -- | |
Settings.Aimbot.ModeUI.Status.Style = 'Custom' | |
Settings.Aimbot.ModeUI['Key']['TextStrokeColor3'] = Settings.Menu.Colors.Enabled | |
---------------------- | |
Func(Settings.Aimbot) | |
elseif (Name == 'Floaty') then | |
Func('Toggle') | |
else | |
Func(true) | |
end | |
end) | |
end | |
if Name:match('Chams') then | |
local ChamSettings = Settings.Chams | |
local TeamSettings = ChamSettings.Team | |
local EnemySettings = ChamSettings.Enemy | |
if Name == 'Team Chams' then | |
NewOption['Key'].Text = '[ \''..TeamSettings.Color[1]..'\' ]' | |
NewOption['Key']['MouseButton1Down']:Connect(function() | |
local ChamColors = ChamSettings.Colors | |
if not TeamSettings.Enabled then return end | |
local Tab, Pos = GetColor(ChamColors, TeamSettings.Color[1]) | |
if (Pos + 1) < #ChamColors then | |
TeamSettings.Color = ChamColors[Pos + 1] | |
else | |
TeamSettings.Color = ChamColors[1] | |
end | |
NewOption['Key'].Text = '[ \''..TeamSettings.Color[1]..'\' ]' | |
Func() | |
end) | |
elseif Name == 'Enemy Chams' then | |
NewOption['Key'].Text = '[ \''..EnemySettings.Color[1]..'\' ]' | |
NewOption['Key']['MouseButton1Down']:Connect(function() | |
local ChamColors = ChamSettings.Colors | |
if not EnemySettings.Enabled then return end | |
local Tab, Pos = GetColor(ChamColors, EnemySettings.Color[1]) | |
if (Pos + 1) < #ChamColors then | |
EnemySettings.Color = ChamColors[Pos + 1] | |
else | |
EnemySettings.Color = ChamColors[1] | |
end | |
NewOption['Key'].Text = '[ \''..EnemySettings.Color[1]..'\' ]' | |
Func() | |
end) | |
elseif Name == 'Toggle Chams' then | |
NewOption['Key'].Text = '[ \'' .. ChamSettings.Transparency .. '\' ]' | |
NewOption['Key']['MouseButton1Down']:Connect(function() | |
if not ChamSettings.Enabled then return end | |
local Trans = ChamSettings.Transparency | |
ChamSettings.Transparency = (Trans < .8 and Trans + (1/10)) or 0 | |
for __, handle in next, (Chams:GetDescendants()) do | |
if handle:IsA('BoxHandleAdornment') then | |
handle.Transparency = ChamSettings.Transparency | |
end | |
end | |
NewOption['Key'].Text = '[ \'' .. ChamSettings.Transparency .. '\' ]' | |
end) | |
end | |
elseif Name == 'Fullbright' then | |
local Fullbright = Settings.Fullbright | |
Fullbright.UI = NewOption | |
NewOption['Key']['MouseButton1Down']:Connect(function() | |
if not Fullbright.Enabled then return end | |
if Fullbright.Current < #Fullbright.Options then | |
Fullbright.Current = Fullbright.Current + 1 | |
else | |
Fullbright.Current = 1 | |
end | |
Func(false) | |
end) | |
elseif Name == 'ESP' then | |
local ESP = Settings.ESP | |
NewOption['Key'].Text = '[ \'' .. ESP.Options[ESP.Current] .. '\' ]' | |
NewOption['Key']['MouseButton1Down']:Connect(function() | |
if not ESP.Enabled then return end | |
if ESP.Current < #ESP.Options then | |
ESP.Current = ESP.Current + 1 | |
else | |
ESP.Current = 1 | |
end | |
Events.ESP:Fire('change') | |
NewOption['Key'].Text = '[ \'' .. ESP.Options[ESP.Current] .. '\' ]' | |
end) | |
elseif Name == 'Aimbot' then | |
local Aimbot = Settings.Aimbot | |
local RangeVal = Aimbot.RangeOptions[Aimbot.Range] | |
if RangeVal == math.huge then | |
NewOption['Key'].Text = '[ ∞ ]' | |
else | |
NewOption['Key'].Text = '[ ' .. RangeVal .. ' ]' | |
end | |
NewOption['Key']['MouseButton1Down']:Connect(function() | |
if not Aimbot.Enabled then return end | |
if Aimbot.Range < #Aimbot.RangeOptions then | |
Aimbot.Range = Aimbot.Range + 1 | |
else | |
Aimbot.Range = 1 | |
end | |
local RangeVal = Aimbot.RangeOptions[Aimbot.Range] | |
if RangeVal == math.huge then | |
NewOption['Key'].Text = '[ ∞ ]' | |
else | |
NewOption['Key'].Text = '[ ' .. RangeVal .. ' ]' | |
end | |
end) | |
elseif Name == 'Aimbot Mode' then | |
local Aimbot = Settings.Aimbot | |
Aimbot.ModeUI = NewOption | |
NewOption['Key'].Text = '[ \'' .. Aimbot.ModeOptions[Aimbot.Mode] .. '\' ]' | |
NewOption['Key']['MouseButton1Down']:Connect(function() | |
if not Aimbot.Enabled then return end | |
if Aimbot.Mode < #Aimbot.ModeOptions then | |
Aimbot.Mode = Aimbot.Mode + 1 | |
else | |
Aimbot.Mode = 1 | |
end | |
NewOption['Key'].Text = '[ \'' .. Aimbot.ModeOptions[Aimbot.Mode] .. '\' ]' | |
end) | |
elseif Name == 'Floaty' then | |
local Floaty = Settings.Floaty | |
Floaty.UI = NewOption | |
NewOption['Key']['MouseButton1Down']:Connect(function() | |
if not Floaty.Enabled then return end | |
if Floaty.Current < #Floaty.Options then | |
Floaty.Current = Floaty.Current + 1 | |
else | |
Floaty.Current = 1 | |
end | |
Func(Floaty.Options[Floaty.Current]) | |
end) | |
end | |
end | |
--[[Players.PlayerRemoving:Connect(function(player) | |
local ESP = ESPFolder:FindFirstChild(player['Name']) | |
if ESP then ESP['Parent'] = nil end | |
end)]] | |
local function toggle(button) | |
local Aimbot = Settings.Aimbot | |
local ActiveUI = Aimbot.ActiveUI | |
local status = Aimbot.Status | |
local text = button['Text'] | |
if text:match('Hide') then | |
status['Hide Menu'] = not status['Hide Menu'] | |
if (status['Hide Menu']) then | |
ActiveUI.Visible = false | |
else | |
ActiveUI.Visible = true | |
end | |
return | |
end | |
local option, val = text:match('%s*(.*)%s*:%s*(.*)') | |
status[option] = not status[option] | |
if status[option] then | |
button.TextColor3 = Color3.fromRGB(0,255,0) | |
else | |
button.TextColor3 = Color3.fromRGB(255,0,0) | |
end | |
button.Text = option .. ': ' .. tostring(status[option]) | |
end | |
Input.InputBegan:Connect(function(input, procc) | |
Keys[input.KeyCode], Inputs[input.UserInputType] = true, true | |
if procc then return end | |
if not input.UserInputType == Enum.UserInputType.Keyboard then | |
return | |
end | |
-- MENU/Floaty -- | |
if input.KeyCode == Enum.KeyCode.Delete then | |
Functions['Menu']() | |
elseif input.KeyCode == Enum.KeyCode.B then | |
Functions['Floaty']('Up') | |
elseif input.KeyCode == Enum.KeyCode.N then | |
Functions['Floaty']('Still') | |
elseif input.KeyCode == Enum.KeyCode.M then | |
Functions['Floaty']('Down') | |
end | |
-- AIMBOT -- | |
local Aimbot = Settings.Aimbot | |
local ActiveUI = Aimbot.ActiveUI | |
if not ActiveUI then return end | |
if input.KeyCode == Enum.KeyCode.H then | |
toggle(Aimbot.Selection[Aimbot.Selected]) | |
elseif not Aimbot.Status['Hide Menu'] then | |
if input.KeyCode == Enum.KeyCode.U then | |
if (Aimbot.Selected > 1) then | |
Aimbot.Selected = Aimbot.Selected - 1 | |
else | |
Aimbot.Selected = #Aimbot.Selection | |
end | |
elseif input.KeyCode == Enum.KeyCode.J then | |
if (Aimbot.Selected < #Aimbot.Selection) then | |
Aimbot.Selected = Aimbot.Selected + 1 | |
else | |
Aimbot.Selected = 1 | |
end | |
end | |
Aimbot.Scrolled = 30 * (Aimbot.Selected - 1) | |
ActiveUI.CanvasPosition = Vector2.new(0, Aimbot.Scrolled) | |
end | |
end) | |
Input.InputEnded:Connect(function(input, procc) | |
Keys[input.KeyCode], Inputs[input.UserInputType] = false, false | |
end) | |
local function TargetHandler(model) | |
if Targets[model] == nil then | |
local event; | |
Targets[model] = Players:GetPlayerFromCharacter(model) or false | |
Events.Targets:Fire('added', model) | |
if not model:IsDescendantOf(World) then | |
if Targets[model] ~= nil then | |
Events.Targets:Fire('removed', model) | |
Targets[model] = nil | |
end | |
return | |
end | |
event = model:GetPropertyChangedSignal('Parent'):Connect(function() | |
if model:IsDescendantOf(World) then return end | |
if Targets[model] ~= nil then | |
Events.Targets:Fire('removed', model) | |
Targets[model] = nil | |
end | |
event:Disconnect() | |
end) | |
end | |
end | |
Player['CharacterAdded']:Connect(function(char) | |
PlayerModel = char | |
end) | |
for __, target in next, (World:GetDescendants()) do | |
coroutine.wrap(function() | |
if target:IsA('Model') and (target ~= PlayerModel) then | |
local hrp = target:WaitForChild('HumanoidRootPart', 1) | |
if hrp and hrp:IsA('BasePart') then | |
TargetHandler(target) | |
end | |
end | |
end)() | |
end | |
World.DescendantAdded:Connect(function(target) | |
if target:IsA('Model') and (target ~= PlayerModel) then | |
local hrp = target:WaitForChild('HumanoidRootPart', 1) | |
if hrp and hrp:IsA('BasePart') then | |
coroutine.wrap(function() | |
TargetHandler(target) | |
end)() | |
end | |
end | |
end) | |
Menu.Parent = CoreGUI |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Fixed issue with spawn